62 files changed, 2273 insertions, 635 deletions
diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index 9776a82e3..afeeb1513 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -8,9 +8,9 @@ license = "MIT OR Apache-2.0"
 description = "Generic LSP server scaffold."
 [dependencies]
-languageserver-types = "0.53.0"
+languageserver-types = "0.53.1"
 log = "0.4.3"
 failure = "0.1.2"
 serde_json = "1.0.24"
-serde = { version = "1.0.71", features = ["derive"] }
+serde = { version = "1.0.83", features = ["derive"] }
 crossbeam-channel = "0.2.4"
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index 4a7b99947..a5d4f65ab 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -9,9 +9,9 @@ log = "0.4.5"
 relative-path = "0.4.0"
 rayon = "1.0.2"
 fst = "0.3.1"
-salsa = "0.8.0"
+salsa = "0.9.0"
 rustc-hash = "1.0"
-parking_lot = "0.6.4"
+parking_lot = "0.7.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_analysis/src/completion/complete_dot.rs b/crates/ra_analysis/src/completion/complete_dot.rs
index 93d657576..f24835d17 100644
--- a/crates/ra_analysis/src/completion/complete_dot.rs
+++ b/crates/ra_analysis/src/completion/complete_dot.rs
@@ -6,20 +6,9 @@ use crate::completion::{CompletionContext, Completions, CompletionKind, Completi
 /// Complete dot accesses, i.e. fields or methods (currently only fields).
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
-    let module = if let Some(module) = &ctx.module {
+    let (function, receiver) = match (&ctx.function, ctx.dot_receiver) {
-        module
+        (Some(function), Some(receiver)) => (function, receiver),
-    } else {
+        _ => return Ok(()),
-        return Ok(());
-    };
-    let function = if let Some(fn_def) = ctx.enclosing_fn {
-        hir::source_binder::function_from_module(ctx.db, module, fn_def)
-    } else {
-        return Ok(());
-    };
-    let receiver = if let Some(receiver) = ctx.dot_receiver {
-        receiver
-    } else {
-        return Ok(());
    };
    let infer_result = function.infer(ctx.db)?;
    let receiver_ty = if let Some(ty) = infer_result.type_of_node(receiver.syntax()) {
diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs
index 5427fcb11..b2486104a 100644
--- a/crates/ra_analysis/src/completion/complete_keyword.rs
+++ b/crates/ra_analysis/src/completion/complete_keyword.rs
@@ -18,7 +18,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
    if !ctx.is_trivial_path {
        return;
    }
-    let fn_def = match ctx.enclosing_fn {
+    let fn_def = match ctx.function_syntax {
        Some(it) => it,
        None => return,
    };
@@ -32,10 +32,15 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        acc.add(keyword("else if", "else if $0 {}"));
    }
    if is_in_loop_body(ctx.leaf) {
-        acc.add(keyword("continue", "continue"));
+        if ctx.can_be_stmt {
-        acc.add(keyword("break", "break"));
+            acc.add(keyword("continue", "continue;"));
+            acc.add(keyword("break", "break;"));
+        } else {
+            acc.add(keyword("continue", "continue"));
+            acc.add(keyword("break", "break"));
+        }
    }
-    acc.add_all(complete_return(fn_def, ctx.is_stmt));
+    acc.add_all(complete_return(fn_def, ctx.can_be_stmt));
 }
 fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
@@ -57,8 +62,8 @@ fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
    false
 }
-fn complete_return(fn_def: ast::FnDef, is_stmt: bool) -> Option<CompletionItem> {
+fn complete_return(fn_def: ast::FnDef, can_be_stmt: bool) -> Option<CompletionItem> {
-    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
+    let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
        (true, true) => "return $0;",
        (true, false) => "return;",
        (false, true) => "return $0",
@@ -75,7 +80,7 @@ mod tests {
    }
    #[test]
-    fn test_completion_kewords() {
+    fn completes_various_keywords_in_function() {
        check_keyword_completion(
            r"
            fn quux() {
@@ -87,13 +92,13 @@ mod tests {
            match "match $0 {}"
            while "while $0 {}"
            loop "loop {$0}"
-            return "return"
+            return "return;"
            "#,
        );
    }
    #[test]
-    fn test_completion_else() {
+    fn completes_else_after_if() {
        check_keyword_completion(
            r"
            fn quux() {
@@ -109,7 +114,7 @@ mod tests {
            loop "loop {$0}"
            else "else {$0}"
            else if "else if $0 {}"
-            return "return"
+            return "return;"
            "#,
        );
    }
@@ -149,7 +154,7 @@ mod tests {
    }
    #[test]
-    fn test_completion_return_no_stmt() {
+    fn dont_add_semi_after_return_if_not_a_statement() {
        check_keyword_completion(
            r"
            fn quux() -> i32 {
@@ -169,7 +174,27 @@ mod tests {
    }
    #[test]
-    fn test_continue_break_completion() {
+    fn last_return_in_block_has_semi() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                if condition {
+                    <|>
+                }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0;"
+            "#,
+        );
+    }
+    #[test]
+    fn completes_break_and_continue_in_loops() {
        check_keyword_completion(
            r"
            fn quux() -> i32 {
@@ -181,11 +206,12 @@ mod tests {
            match "match $0 {}"
            while "while $0 {}"
            loop "loop {$0}"
-            continue "continue"
+            continue "continue;"
-            break "break"
+            break "break;"
-            return "return $0"
+            return "return $0;"
            "#,
        );
+        // No completion: lambda isolates control flow
        check_keyword_completion(
            r"
            fn quux() -> i32 {
@@ -197,8 +223,32 @@ mod tests {
            match "match $0 {}"
            while "while $0 {}"
            loop "loop {$0}"
-            return "return $0"
+            return "return $0;"
            "#,
        );
    }
+    #[test]
+    fn no_semi_after_break_continue_in_expr() {
+        check_keyword_completion(
+            r"
+            fn f() {
+                loop {
+                    match () {
+                        () => br<|>
+                    }
+                }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            continue "continue"
+            break "break"
+            return "return"
+            "#,
+        )
+    }
 }
diff --git a/crates/ra_analysis/src/completion/complete_path.rs b/crates/ra_analysis/src/completion/complete_path.rs
index aaa2c7cee..4723a65a6 100644
--- a/crates/ra_analysis/src/completion/complete_path.rs
+++ b/crates/ra_analysis/src/completion/complete_path.rs
@@ -1,6 +1,6 @@
 use crate::{
    Cancelable,
-    completion::{CompletionItem, Completions, CompletionKind, CompletionContext},
+    completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext},
 };
 pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
@@ -12,16 +12,25 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> C
        Some(it) => it,
        None => return Ok(()),
    };
-    let target_module = match def_id.resolve(ctx.db)? {
+    match def_id.resolve(ctx.db)? {
-        hir::Def::Module(it) => it,
+        hir::Def::Module(module) => {
+            let module_scope = module.scope(ctx.db)?;
+            module_scope.entries().for_each(|(name, res)| {
+                CompletionItem::new(CompletionKind::Reference, name.to_string())
+                    .from_resolution(ctx, res)
+                    .add_to(acc)
+            });
+        }
+        hir::Def::Enum(e) => e
+            .variants(ctx.db)?
+            .into_iter()
+            .for_each(|(name, _variant)| {
+                CompletionItem::new(CompletionKind::Reference, name.to_string())
+                    .kind(CompletionItemKind::EnumVariant)
+                    .add_to(acc)
+            }),
        _ => return Ok(()),
    };
-    let module_scope = target_module.scope(ctx.db)?;
-    module_scope.entries().for_each(|(name, res)| {
-        CompletionItem::new(CompletionKind::Reference, name.to_string())
-            .from_resolution(ctx.db, res)
-            .add_to(acc)
-    });
    Ok(())
 }
@@ -92,4 +101,28 @@ mod tests {
            "Spam",
        );
    }
+    #[test]
+    fn completes_enum_variant() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            enum E { Foo, Bar(i32) }
+            fn foo() { let _ = E::<|> }
+            ",
+            "Foo;Bar",
+        );
+    }
+    #[test]
+    fn dont_render_function_parens_in_use_item() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod m { pub fn foo() {} }
+            use crate::m::f<|>;
+            ",
+            "foo",
+        )
+    }
 }
diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs
index a57670e3b..daf666505 100644
--- a/crates/ra_analysis/src/completion/complete_scope.rs
+++ b/crates/ra_analysis/src/completion/complete_scope.rs
@@ -14,8 +14,7 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) ->
        Some(it) => it,
        None => return Ok(()),
    };
-    if let Some(fn_def) = ctx.enclosing_fn {
+    if let Some(function) = &ctx.function {
-        let function = hir::source_binder::function_from_module(ctx.db, module, fn_def);
        let scopes = function.scopes(ctx.db);
        complete_fn(acc, &scopes, ctx.offset);
    }
@@ -35,7 +34,7 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) ->
        })
        .for_each(|(name, res)| {
            CompletionItem::new(CompletionKind::Reference, name.to_string())
-                .from_resolution(ctx.db, res)
+                .from_resolution(ctx, res)
                .add_to(acc)
        });
    Ok(())
@@ -75,7 +74,7 @@ mod tests {
                let z = ();
            }
            ",
-            "y;x;quux",
+            r#"y;x;quux "quux($0)""#,
        );
    }
@@ -93,7 +92,7 @@ mod tests {
                }
            }
            ",
-            "b;a;quux",
+            r#"b;a;quux "quux()$0""#,
        );
    }
@@ -107,7 +106,7 @@ mod tests {
                }
            }
            ",
-            "x;quux",
+            r#"x;quux "quux()$0""#,
        );
    }
@@ -121,7 +120,7 @@ mod tests {
                <|>
            }
            ",
-            "quux;Foo;Baz",
+            r#"quux "quux()$0";Foo;Baz"#,
        );
    }
@@ -135,7 +134,7 @@ mod tests {
                fn quux() { <|> }
            }
            ",
-            "quux;Bar",
+            r#"quux "quux()$0";Bar"#,
        );
    }
@@ -146,12 +145,12 @@ mod tests {
            struct Foo;
            fn x() -> <|>
            ",
-            "Foo;x",
+            r#"Foo;x "x()$0""#,
        )
    }
    #[test]
-    fn dont_show_to_completions_for_shadowing() {
+    fn dont_show_both_completions_for_shadowing() {
        check_reference_completion(
            r"
            fn foo() -> {
@@ -162,7 +161,7 @@ mod tests {
                }
            }
            ",
-            "bar;foo",
+            r#"bar;foo "foo()$0""#,
        )
    }
@@ -170,4 +169,24 @@ mod tests {
    fn completes_self_in_methods() {
        check_reference_completion(r"impl S { fn foo(&self) { <|> } }", "self")
    }
+    #[test]
+    fn inserts_parens_for_function_calls() {
+        check_reference_completion(
+            r"
+            fn no_args() {}
+            fn main() { no_<|> }
+            ",
+            r#"no_args "no_args()$0"
+               main "main()$0""#,
+        );
+        check_reference_completion(
+            r"
+            fn with_args(x: i32, y: String) {}
+            fn main() { with_<|> }
+            ",
+            r#"main "main()$0"
+               with_args "with_args($0)""#,
+        );
+    }
 }
diff --git a/crates/ra_analysis/src/completion/complete_snippet.rs b/crates/ra_analysis/src/completion/complete_snippet.rs
index fb9da0a4f..a495751dd 100644
--- a/crates/ra_analysis/src/completion/complete_snippet.rs
+++ b/crates/ra_analysis/src/completion/complete_snippet.rs
@@ -7,7 +7,7 @@ fn snippet(label: &str, snippet: &str) -> Builder {
 }
 pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path && ctx.enclosing_fn.is_some()) {
+    if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
        return;
    }
    snippet("pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs
index 978772fd4..4685c9328 100644
--- a/crates/ra_analysis/src/completion/completion_context.rs
+++ b/crates/ra_analysis/src/completion/completion_context.rs
@@ -22,14 +22,17 @@ pub(super) struct CompletionContext<'a> {
    pub(super) offset: TextUnit,
    pub(super) leaf: SyntaxNodeRef<'a>,
    pub(super) module: Option<hir::Module>,
-    pub(super) enclosing_fn: Option<ast::FnDef<'a>>,
+    pub(super) function: Option<hir::Function>,
+    pub(super) function_syntax: Option<ast::FnDef<'a>>,
+    pub(super) use_item_syntax: Option<ast::UseItem<'a>>,
    pub(super) is_param: bool,
    /// A single-indent path, like `foo`.
    pub(super) is_trivial_path: bool,
    /// If not a trivial, path, the prefix (qualifier).
    pub(super) path_prefix: Option<hir::Path>,
    pub(super) after_if: bool,
-    pub(super) is_stmt: bool,
+    /// `true` if we are a statement or a last expr in the block.
+    pub(super) can_be_stmt: bool,
    /// Something is typed at the "top" level, in module or impl/trait.
    pub(super) is_new_item: bool,
    /// The receiver if this is a field or method access, i.e. writing something.<|>
@@ -52,12 +55,14 @@ impl<'a> CompletionContext<'a> {
            leaf,
            offset: position.offset,
            module,
-            enclosing_fn: None,
+            function: None,
+            function_syntax: None,
+            use_item_syntax: None,
            is_param: false,
            is_trivial_path: false,
            path_prefix: None,
            after_if: false,
-            is_stmt: false,
+            can_be_stmt: false,
            is_new_item: false,
            dot_receiver: None,
            is_method_call: false,
@@ -112,11 +117,20 @@ impl<'a> CompletionContext<'a> {
            _ => (),
        }
-        self.enclosing_fn = self
+        self.use_item_syntax = self.leaf.ancestors().find_map(ast::UseItem::cast);
+        self.function_syntax = self
            .leaf
            .ancestors()
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::FnDef::cast);
+        match (&self.module, self.function_syntax) {
+            (Some(module), Some(fn_def)) => {
+                let function = source_binder::function_from_module(self.db, module, fn_def);
+                self.function = Some(function);
+            }
+            _ => (),
+        }
        let parent = match name_ref.syntax().parent() {
            Some(it) => it,
@@ -134,13 +148,22 @@ impl<'a> CompletionContext<'a> {
            if path.qualifier().is_none() {
                self.is_trivial_path = true;
-                self.is_stmt = match name_ref
+                self.can_be_stmt = match name_ref
                    .syntax()
                    .ancestors()
                    .filter_map(ast::ExprStmt::cast)
                    .next()
                {
-                    None => false,
+                    None => {
+                        name_ref
+                            .syntax()
+                            .ancestors()
+                            .filter_map(ast::Block::cast)
+                            .next()
+                            .and_then(|block| block.expr())
+                            .map(|e| e.syntax().range())
+                            == Some(name_ref.syntax().range())
+                    }
                    Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
                };
diff --git a/crates/ra_analysis/src/completion/completion_item.rs b/crates/ra_analysis/src/completion/completion_item.rs
index c9f9f495d..cd4d529f9 100644
--- a/crates/ra_analysis/src/completion/completion_item.rs
+++ b/crates/ra_analysis/src/completion/completion_item.rs
@@ -1,7 +1,7 @@
-use crate::db;
 use hir::PerNs;
+use crate::completion::CompletionContext;
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
 /// `CompletionItem`, use `new` method and the `Builder` struct.
@@ -29,6 +29,7 @@ pub enum CompletionItemKind {
    Function,
    Struct,
    Enum,
+    EnumVariant,
    Binding,
    Field,
 }
@@ -117,12 +118,12 @@ impl Builder {
        self.kind = Some(kind);
        self
    }
-    pub(crate) fn from_resolution(
+    pub(super) fn from_resolution(
        mut self,
-        db: &db::RootDatabase,
+        ctx: &CompletionContext,
        resolution: &hir::Resolution,
    ) -> Builder {
-        let resolved = resolution.def_id.and_then(|d| d.resolve(db).ok());
+        let resolved = resolution.def_id.and_then(|d| d.resolve(ctx.db).ok());
        let kind = match resolved {
            PerNs {
                types: Some(hir::Def::Module(..)),
@@ -137,14 +138,29 @@ impl Builder {
                ..
            } => CompletionItemKind::Enum,
            PerNs {
-                values: Some(hir::Def::Function(..)),
+                values: Some(hir::Def::Function(function)),
                ..
-            } => CompletionItemKind::Function,
+            } => return self.from_function(ctx, function),
            _ => return self,
        };
        self.kind = Some(kind);
        self
    }
+    fn from_function(mut self, ctx: &CompletionContext, function: hir::Function) -> Builder {
+        // If not an import, add parenthesis automatically.
+        if ctx.use_item_syntax.is_none() {
+            if let Some(sig_info) = function.signature_info(ctx.db) {
+                if sig_info.params.is_empty() {
+                    self.snippet = Some(format!("{}()$0", self.label));
+                } else {
+                    self.snippet = Some(format!("{}($0)", self.label));
+                }
+            }
+        }
+        self.kind = Some(CompletionItemKind::Function);
+        self
+    }
 }
 impl Into<CompletionItem> for Builder {
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 036e284bf..b072a5eba 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -91,7 +91,6 @@ salsa::database_storage! {
            fn file_item() for hir::db::FileItemQuery;
            fn input_module_items() for hir::db::InputModuleItemsQuery;
            fn item_map() for hir::db::ItemMapQuery;
-            fn fn_syntax() for hir::db::FnSyntaxQuery;
            fn submodules() for hir::db::SubmodulesQuery;
            fn infer() for hir::db::InferQuery;
            fn type_for_def() for hir::db::TypeForDefQuery;
diff --git a/crates/ra_analysis/src/extend_selection.rs b/crates/ra_analysis/src/extend_selection.rs
new file mode 100644
index 000000000..cde6ee101
--- /dev/null
+++ b/crates/ra_analysis/src/extend_selection.rs
@@ -0,0 +1,51 @@
+use ra_db::SyntaxDatabase;
+use ra_syntax::{
+    SyntaxNodeRef, AstNode,
+    ast, algo::find_covering_node,
+};
+use crate::{
+    TextRange, FileRange,
+    db::RootDatabase,
+};
+pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
+    let source_file = db.source_file(frange.file_id);
+    if let Some(macro_call) = find_macro_call(source_file.syntax(), frange.range) {
+        if let Some(exp) = crate::macros::expand(db, frange.file_id, macro_call) {
+            if let Some(dst_range) = exp.map_range_forward(frange.range) {
+                if let Some(dst_range) = ra_editor::extend_selection(exp.source_file(), dst_range) {
+                    if let Some(src_range) = exp.map_range_back(dst_range) {
+                        return src_range;
+                    }
+                }
+            }
+        }
+    }
+    ra_editor::extend_selection(&source_file, frange.range).unwrap_or(frange.range)
+}
+fn find_macro_call(node: SyntaxNodeRef, range: TextRange) -> Option<ast::MacroCall> {
+    find_covering_node(node, range)
+        .ancestors()
+        .find_map(ast::MacroCall::cast)
+}
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::single_file_with_range;
+    use test_utils::assert_eq_dbg;
+    #[test]
+    fn extend_selection_inside_macros() {
+        let (analysis, frange) = single_file_with_range(
+            "
+            fn main() {
+                ctry!(foo(|x| <|>x<|>));
+            }
+        ",
+        );
+        let r = analysis.extend_selection(frange);
+        assert_eq_dbg("[51; 56)", &r);
+    }
+}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 38a5c1a7d..bff2e00c9 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -7,10 +7,7 @@ use rayon::prelude::*;
 use salsa::{Database, ParallelDatabase};
 use hir::{
-    self,
+    self, FnSignatureInfo, Problem, source_binder,
-    FnSignatureInfo,
-    Problem,
-    source_binder,
 };
 use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
 use ra_editor::{self, FileSymbol, find_node_at_offset, LineIndex, LocalEdit, Severity};
@@ -26,7 +23,7 @@ use crate::{
    AnalysisChange,
    Cancelable,
    completion::{CompletionItem, completions},
-    CrateId, db, Diagnostic, FileId, FilePosition, FileSystemEdit,
+    CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
    Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
    symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase},
 };
@@ -123,9 +120,6 @@ impl AnalysisHostImpl {
            .query(ra_db::SourceFileQuery)
            .sweep(salsa::SweepStrategy::default().discard_values());
        self.db
-            .query(hir::db::FnSyntaxQuery)
-            .sweep(salsa::SweepStrategy::default().discard_values());
-        self.db
            .query(hir::db::SourceFileItemsQuery)
            .sweep(salsa::SweepStrategy::default().discard_values());
        self.db
@@ -146,6 +140,9 @@ impl fmt::Debug for AnalysisImpl {
 }
 impl AnalysisImpl {
+    pub fn file_text(&self, file_id: FileId) -> Arc<String> {
+        self.db.file_text(file_id)
+    }
    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
        self.db.source_file(file_id)
    }
@@ -243,7 +240,7 @@ impl AnalysisImpl {
                    rr.add_resolution(
                        position.file_id,
                        FileSymbol {
-                            name: entry.name().clone(),
+                            name: entry.name().to_string().into(),
                            node_range: entry.ptr().range(),
                            kind: NAME,
                        },
@@ -261,23 +258,21 @@ impl AnalysisImpl {
            let mut rr = ReferenceResolution::new(name.syntax().range());
            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                if module.has_semi() {
-                    let parent_module =
+                    if let Some(child_module) =
-                        source_binder::module_from_file_id(&*self.db, position.file_id)?;
+                        source_binder::module_from_declaration(&*self.db, position.file_id, module)?
-                    let child_name = module.name();
+                    {
-                    match (parent_module, child_name) {
+                        let file_id = child_module.source().file_id();
-                        (Some(parent_module), Some(child_name)) => {
+                        let name = match child_module.name() {
-                            if let Some(child) = parent_module.child(&child_name.text()) {
+                            Some(name) => name.to_string().into(),
-                                let file_id = child.source().file_id();
+                            None => "".into(),
-                                let symbol = FileSymbol {
+                        };
-                                    name: child_name.text(),
+                        let symbol = FileSymbol {
-                                    node_range: TextRange::offset_len(0.into(), 0.into()),
+                            name,
-                                    kind: MODULE,
+                            node_range: TextRange::offset_len(0.into(), 0.into()),
-                                };
+                            kind: MODULE,
-                                rr.add_resolution(file_id, symbol);
+                        };
-                                return Ok(Some(rr));
+                        rr.add_resolution(file_id, symbol);
-                            }
+                        return Ok(Some(rr));
-                        }
-                        _ => (),
                    }
                }
            }
@@ -334,16 +329,6 @@ impl AnalysisImpl {
            Ok(Some((binding, descr)))
        }
    }
-    pub fn doc_comment_for(
-        &self,
-        file_id: FileId,
-        symbol: FileSymbol,
-    ) -> Cancelable<Option<String>> {
-        let file = self.db.source_file(file_id);
-        Ok(symbol.docs(&file))
-    }
    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
        let file = self.db.source_file(file_id);
        let result = match (symbol.description(&file), symbol.docs(&file)) {
@@ -422,19 +407,21 @@ impl AnalysisImpl {
        Ok(res)
    }
-    pub fn assists(&self, file_id: FileId, range: TextRange) -> Vec<SourceChange> {
+    pub fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
-        let file = self.file_syntax(file_id);
+        let file = self.file_syntax(frange.file_id);
-        let offset = range.start();
+        let offset = frange.range.start();
        let actions = vec![
            ra_editor::flip_comma(&file, offset).map(|f| f()),
            ra_editor::add_derive(&file, offset).map(|f| f()),
            ra_editor::add_impl(&file, offset).map(|f| f()),
            ra_editor::make_pub_crate(&file, offset).map(|f| f()),
-            ra_editor::introduce_variable(&file, range).map(|f| f()),
+            ra_editor::introduce_variable(&file, frange.range).map(|f| f()),
        ];
        actions
            .into_iter()
-            .filter_map(|local_edit| Some(SourceChange::from_local_edit(file_id, local_edit?)))
+            .filter_map(|local_edit| {
+                Some(SourceChange::from_local_edit(frange.file_id, local_edit?))
+            })
            .collect()
    }
@@ -505,18 +492,15 @@ impl AnalysisImpl {
        Ok(None)
    }
-    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
+    pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
-        let file = self.db.source_file(file_id);
+        let file = self.db.source_file(frange.file_id);
        let syntax = file.syntax();
-        let node = find_covering_node(syntax, range);
+        let node = find_covering_node(syntax, frange.range);
-        let parent_fn = node.ancestors().filter_map(FnDef::cast).next();
+        let parent_fn = ctry!(node.ancestors().find_map(FnDef::cast));
-        let parent_fn = if let Some(p) = parent_fn {
-            p
-        } else {
-            return Ok(None);
-        };
        let function = ctry!(source_binder::function_from_source(
-            &*self.db, file_id, parent_fn
+            &*self.db,
+            frange.file_id,
+            parent_fn
        )?);
        let infer = function.infer(&*self.db)?;
        Ok(infer.type_of_node(node).map(|t| t.to_string()))
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 476d1b438..9f5e9f358 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -16,6 +16,10 @@ mod completion;
 mod symbol_index;
 pub mod mock_analysis;
+mod extend_selection;
+mod syntax_highlighting;
+mod macros;
 use std::{fmt, sync::Arc};
 use rustc_hash::FxHashMap;
@@ -37,7 +41,7 @@ pub use ra_editor::{
 pub use hir::FnSignatureInfo;
 pub use ra_db::{
-    Canceled, Cancelable, FilePosition,
+    Canceled, Cancelable, FilePosition, FileRange,
    CrateGraph, CrateId, SourceRootId, FileId
 };
@@ -270,14 +274,17 @@ pub struct Analysis {
 }
 impl Analysis {
+    pub fn file_text(&self, file_id: FileId) -> Arc<String> {
+        self.imp.file_text(file_id)
+    }
    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
        self.imp.file_syntax(file_id).clone()
    }
    pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
        self.imp.file_line_index(file_id)
    }
-    pub fn extend_selection(&self, file: &SourceFileNode, range: TextRange) -> TextRange {
+    pub fn extend_selection(&self, frange: FileRange) -> TextRange {
-        ra_editor::extend_selection(file, range).unwrap_or(range)
+        extend_selection::extend_selection(&self.imp.db, frange)
    }
    pub fn matching_brace(&self, file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
        ra_editor::matching_brace(file, offset)
@@ -286,9 +293,9 @@ impl Analysis {
        let file = self.imp.file_syntax(file_id);
        ra_editor::syntax_tree(&file)
    }
-    pub fn join_lines(&self, file_id: FileId, range: TextRange) -> SourceChange {
+    pub fn join_lines(&self, frange: FileRange) -> SourceChange {
-        let file = self.imp.file_syntax(file_id);
+        let file = self.imp.file_syntax(frange.file_id);
-        SourceChange::from_local_edit(file_id, ra_editor::join_lines(&file, range))
+        SourceChange::from_local_edit(frange.file_id, ra_editor::join_lines(&file, frange.range))
    }
    pub fn on_enter(&self, position: FilePosition) -> Option<SourceChange> {
        let file = self.imp.file_syntax(position.file_id);
@@ -323,13 +330,6 @@ impl Analysis {
    pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
        self.imp.find_all_refs(position)
    }
-    pub fn doc_comment_for(
-        &self,
-        file_id: FileId,
-        symbol: FileSymbol,
-    ) -> Cancelable<Option<String>> {
-        self.imp.doc_comment_for(file_id, symbol)
-    }
    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
        self.imp.doc_text_for(file_id, symbol)
    }
@@ -347,14 +347,13 @@ impl Analysis {
        Ok(ra_editor::runnables(&file))
    }
    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        let file = self.imp.file_syntax(file_id);
+        syntax_highlighting::highlight(&*self.imp.db, file_id)
-        Ok(ra_editor::highlight(&file))
    }
    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
        self.imp.completions(position)
    }
-    pub fn assists(&self, file_id: FileId, range: TextRange) -> Cancelable<Vec<SourceChange>> {
+    pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<SourceChange>> {
-        Ok(self.imp.assists(file_id, range))
+        Ok(self.imp.assists(frange))
    }
    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
        self.imp.diagnostics(file_id)
@@ -365,8 +364,8 @@ impl Analysis {
    ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
        self.imp.resolve_callable(position)
    }
-    pub fn type_of(&self, file_id: FileId, range: TextRange) -> Cancelable<Option<String>> {
+    pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
-        self.imp.type_of(file_id, range)
+        self.imp.type_of(frange)
    }
 }
diff --git a/crates/ra_analysis/src/macros.rs b/crates/ra_analysis/src/macros.rs
new file mode 100644
index 000000000..b9feb7fad
--- /dev/null
+++ b/crates/ra_analysis/src/macros.rs
@@ -0,0 +1,75 @@
+/// Begining of macro expansion.
+///
+/// This code should be moved out of ra_analysis into hir (?) ideally.
+use ra_syntax::{ast, AstNode, SourceFileNode, TextRange};
+use crate::{db::RootDatabase, FileId};
+pub(crate) fn expand(
+    _db: &RootDatabase,
+    _file_id: FileId,
+    macro_call: ast::MacroCall,
+) -> Option<MacroExpansion> {
+    let path = macro_call.path()?;
+    if path.qualifier().is_some() {
+        return None;
+    }
+    let name_ref = path.segment()?.name_ref()?;
+    if name_ref.text() != "ctry" {
+        return None;
+    }
+    let arg = macro_call.token_tree()?;
+    let text = format!(
+        r"
+        fn dummy() {{
+            match {} {{
+                None => return Ok(None),
+                Some(it) => it,
+            }}
+        }}",
+        arg.syntax().text()
+    );
+    let file = SourceFileNode::parse(&text);
+    let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
+    let match_arg = match_expr.expr()?;
+    let ranges_map = vec![(arg.syntax().range(), match_arg.syntax().range())];
+    let res = MacroExpansion {
+        source_file: file,
+        ranges_map,
+    };
+    Some(res)
+}
+pub(crate) struct MacroExpansion {
+    pub(crate) source_file: SourceFileNode,
+    pub(crate) ranges_map: Vec<(TextRange, TextRange)>,
+}
+impl MacroExpansion {
+    pub(crate) fn source_file(&self) -> &SourceFileNode {
+        &self.source_file
+    }
+    pub(crate) fn map_range_back(&self, tgt_range: TextRange) -> Option<TextRange> {
+        for (s_range, t_range) in self.ranges_map.iter() {
+            if tgt_range.is_subrange(&t_range) {
+                let tgt_at_zero_range = tgt_range - tgt_range.start();
+                let tgt_range_offset = tgt_range.start() - t_range.start();
+                let src_range = tgt_at_zero_range + tgt_range_offset + s_range.start();
+                return Some(src_range);
+            }
+        }
+        None
+    }
+    pub(crate) fn map_range_forward(&self, src_range: TextRange) -> Option<TextRange> {
+        for (s_range, t_range) in self.ranges_map.iter() {
+            if src_range.is_subrange(&s_range) {
+                let src_at_zero_range = src_range - src_range.start();
+                let src_range_offset = src_range.start() - s_range.start();
+                let src_range = src_at_zero_range + src_range_offset + t_range.start();
+                return Some(src_range);
+            }
+        }
+        None
+    }
+}
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 5ce2aa2b4..960529404 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -1,10 +1,10 @@
 use std::sync::Arc;
 use relative_path::RelativePathBuf;
-use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use test_utils::{extract_offset, extract_range, parse_fixture, CURSOR_MARKER};
 use ra_db::mock::FileMap;
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition, SourceRootId};
+use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition, FileRange, SourceRootId};
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -66,6 +66,12 @@ impl MockAnalysis {
        self.files.push((path.to_string(), text.to_string()));
        FilePosition { file_id, offset }
    }
+    pub fn add_file_with_range(&mut self, path: &str, text: &str) -> FileRange {
+        let (range, text) = extract_range(text);
+        let file_id = FileId((self.files.len() + 1) as u32);
+        self.files.push((path.to_string(), text.to_string()));
+        FileRange { file_id, range }
+    }
    pub fn id_of(&self, path: &str) -> FileId {
        let (idx, _) = self
            .files
@@ -115,3 +121,10 @@ pub fn single_file_with_position(code: &str) -> (Analysis, FilePosition) {
    let pos = mock.add_file_with_position("/main.rs", code);
    (mock.analysis(), pos)
 }
+/// Creates analysis for a single file, returns range marked with a pair of <|>.
+pub fn single_file_with_range(code: &str) -> (Analysis, FileRange) {
+    let mut mock = MockAnalysis::new();
+    let pos = mock.add_file_with_range("/main.rs", code);
+    (mock.analysis(), pos)
+}
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
new file mode 100644
index 000000000..38219da71
--- /dev/null
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -0,0 +1,63 @@
+use ra_syntax::{ast, AstNode,};
+use ra_editor::HighlightedRange;
+use ra_db::SyntaxDatabase;
+use crate::{
+    db::RootDatabase,
+    FileId, Cancelable,
+};
+pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
+    let source_file = db.source_file(file_id);
+    let mut res = ra_editor::highlight(&source_file);
+    for macro_call in source_file
+        .syntax()
+        .descendants()
+        .filter_map(ast::MacroCall::cast)
+    {
+        if let Some(exp) = crate::macros::expand(db, file_id, macro_call) {
+            let mapped_ranges = ra_editor::highlight(exp.source_file())
+                .into_iter()
+                .filter_map(|r| {
+                    let mapped_range = exp.map_range_back(r.range)?;
+                    let res = HighlightedRange {
+                        range: mapped_range,
+                        tag: r.tag,
+                    };
+                    Some(res)
+                });
+            res.extend(mapped_ranges);
+        }
+    }
+    Ok(res)
+}
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::single_file;
+    use test_utils::assert_eq_dbg;
+    #[test]
+    fn highlights_code_inside_macros() {
+        let (analysis, file_id) = single_file(
+            "
+            fn main() {
+                ctry!({ let x = 92; x});
+            }
+        ",
+        );
+        let highlights = analysis.highlight(file_id).unwrap();
+        assert_eq_dbg(
+            r#"[HighlightedRange { range: [13; 15), tag: "keyword" },
+                HighlightedRange { range: [16; 20), tag: "function" },
+                HighlightedRange { range: [41; 46), tag: "macro" },
+                HighlightedRange { range: [49; 52), tag: "keyword" },
+                HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [49; 52), tag: "keyword" },
+                HighlightedRange { range: [53; 54), tag: "function" },
+                HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [61; 62), tag: "text" }]"#,
+            &highlights,
+        )
+    }
+}
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index 4be32b5f3..75bcf2b39 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -7,9 +7,9 @@ authors = ["Aleksey Kladov <[email protected]>"]
 [dependencies]
 backtrace = "0.3.1"
 relative-path = "0.4.0"
-salsa = "0.8.0"
+salsa = "0.9.0"
 rustc-hash = "1.0"
-parking_lot = "0.6.4"
+parking_lot = "0.7.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 1f7c9187b..7181f2950 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -8,13 +8,13 @@ pub mod mock;
 use std::sync::Arc;
 use ra_editor::LineIndex;
-use ra_syntax::{TextUnit, SourceFileNode};
+use ra_syntax::{TextUnit, TextRange, SourceFileNode};
 pub use crate::{
    cancelation::{Canceled, Cancelable},
    syntax_ptr::LocalSyntaxPtr,
    input::{
-        FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph,
+        FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph, Dependency,
        FileTextQuery, FileSourceRootQuery, SourceRootQuery, LocalRootsQuery, LibraryRootsQuery, CrateGraphQuery,
        FileRelativePathQuery
    },
@@ -70,3 +70,9 @@ pub struct FilePosition {
    pub file_id: FileId,
    pub offset: TextUnit,
 }
+#[derive(Clone, Copy, Debug)]
+pub struct FileRange {
+    pub file_id: FileId,
+    pub range: TextRange,
+}
diff --git a/crates/ra_editor/Cargo.toml b/crates/ra_editor/Cargo.toml
index f39fe4af6..a97d2308f 100644
--- a/crates/ra_editor/Cargo.toml
+++ b/crates/ra_editor/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["Aleksey Kladov <[email protected]>"]
 publish = false
 [dependencies]
-itertools = "0.7.8"
+itertools = "0.8.0"
 superslice = "0.1.0"
 join_to_string = "0.1.1"
 rustc-hash = "1.0"
diff --git a/crates/ra_editor/src/diagnostics.rs b/crates/ra_editor/src/diagnostics.rs
new file mode 100644
index 000000000..1b336cfe2
--- /dev/null
+++ b/crates/ra_editor/src/diagnostics.rs
@@ -0,0 +1,276 @@
+use itertools::Itertools;
+use ra_syntax::{
+    ast::{self, AstNode},
+    Location,
+    SourceFileNode,
+    SyntaxKind,
+    TextRange,
+};
+use ra_syntax::SyntaxNodeRef;
+use ra_text_edit::{
+    TextEdit,
+    TextEditBuilder,
+};
+use crate::{
+    Diagnostic,
+    LocalEdit,
+    Severity,
+};
+pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
+    fn location_to_range(location: Location) -> TextRange {
+        match location {
+            Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
+            Location::Range(range) => range,
+        }
+    }
+    let mut errors: Vec<Diagnostic> = file
+        .errors()
+        .into_iter()
+        .map(|err| Diagnostic {
+            range: location_to_range(err.location()),
+            msg: format!("Syntax Error: {}", err),
+            severity: Severity::Error,
+            fix: None,
+        })
+        .collect();
+    for node in file.syntax().descendants() {
+        check_unnecessary_braces_in_use_statement(&mut errors, node);
+        check_struct_shorthand_initialization(&mut errors, node);
+    }
+    errors
+}
+fn check_unnecessary_braces_in_use_statement(
+    acc: &mut Vec<Diagnostic>,
+    node: SyntaxNodeRef,
+) -> Option<()> {
+    let use_tree_list = ast::UseTreeList::cast(node)?;
+    if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
+        let range = use_tree_list.syntax().range();
+        let edit =
+            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree)
+                .unwrap_or_else(|| {
+                    let to_replace = single_use_tree.syntax().text().to_string();
+                    let mut edit_builder = TextEditBuilder::new();
+                    edit_builder.delete(range);
+                    edit_builder.insert(range.start(), to_replace);
+                    edit_builder.finish()
+                });
+        acc.push(Diagnostic {
+            range,
+            msg: format!("Unnecessary braces in use statement"),
+            severity: Severity::WeakWarning,
+            fix: Some(LocalEdit {
+                label: "Remove unnecessary braces".to_string(),
+                edit,
+                cursor_position: None,
+            }),
+        });
+    }
+    Some(())
+}
+fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
+    single_use_tree: ast::UseTree,
+) -> Option<TextEdit> {
+    let use_tree_list_node = single_use_tree.syntax().parent()?;
+    if single_use_tree
+        .path()?
+        .segment()?
+        .syntax()
+        .first_child()?
+        .kind()
+        == SyntaxKind::SELF_KW
+    {
+        let start = use_tree_list_node.prev_sibling()?.range().start();
+        let end = use_tree_list_node.range().end();
+        let range = TextRange::from_to(start, end);
+        let mut edit_builder = TextEditBuilder::new();
+        edit_builder.delete(range);
+        return Some(edit_builder.finish());
+    }
+    None
+}
+fn check_struct_shorthand_initialization(
+    acc: &mut Vec<Diagnostic>,
+    node: SyntaxNodeRef,
+) -> Option<()> {
+    let struct_lit = ast::StructLit::cast(node)?;
+    let named_field_list = struct_lit.named_field_list()?;
+    for named_field in named_field_list.fields() {
+        if let (Some(name_ref), Some(expr)) = (named_field.name_ref(), named_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 mut edit_builder = TextEditBuilder::new();
+                edit_builder.delete(named_field.syntax().range());
+                edit_builder.insert(named_field.syntax().range().start(), field_name);
+                let edit = edit_builder.finish();
+                acc.push(Diagnostic {
+                    range: named_field.syntax().range(),
+                    msg: format!("Shorthand struct initialization"),
+                    severity: Severity::WeakWarning,
+                    fix: Some(LocalEdit {
+                        label: "use struct shorthand initialization".to_string(),
+                        edit,
+                        cursor_position: None,
+                    }),
+                });
+            }
+        }
+    }
+    Some(())
+}
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::assert_eq_text;
+    use super::*;
+    type DiagnosticChecker = fn(&mut Vec<Diagnostic>, SyntaxNodeRef) -> Option<()>;
+    fn check_not_applicable(code: &str, func: DiagnosticChecker) {
+        let file = SourceFileNode::parse(code);
+        let mut diagnostics = Vec::new();
+        for node in file.syntax().descendants() {
+            func(&mut diagnostics, node);
+        }
+        assert!(diagnostics.is_empty());
+    }
+    fn check_apply(before: &str, after: &str, func: DiagnosticChecker) {
+        let file = SourceFileNode::parse(before);
+        let mut diagnostics = Vec::new();
+        for node in file.syntax().descendants() {
+            func(&mut diagnostics, node);
+        }
+        let diagnostic = diagnostics
+            .pop()
+            .unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
+        let fix = diagnostic.fix.unwrap();
+        let actual = fix.edit.apply(&before);
+        assert_eq_text!(after, &actual);
+    }
+    #[test]
+    fn test_check_unnecessary_braces_in_use_statement() {
+        check_not_applicable(
+            "
+            use a;
+            use a::{c, d::e};
+        ",
+            check_unnecessary_braces_in_use_statement,
+        );
+        check_apply(
+            "use {b};",
+            "use b;",
+            check_unnecessary_braces_in_use_statement,
+        );
+        check_apply(
+            "use a::{c};",
+            "use a::c;",
+            check_unnecessary_braces_in_use_statement,
+        );
+        check_apply(
+            "use a::{self};",
+            "use a;",
+            check_unnecessary_braces_in_use_statement,
+        );
+        check_apply(
+            "use a::{c, d::{e}};",
+            "use a::{c, d::e};",
+            check_unnecessary_braces_in_use_statement,
+        );
+    }
+    #[test]
+    fn test_check_struct_shorthand_initialization() {
+        check_not_applicable(
+            r#"
+            struct A {
+                a: &'static str
+            }
+            fn main() {
+                A {
+                    a: "hello"
+                }
+            }
+        "#,
+            check_struct_shorthand_initialization,
+        );
+        check_apply(
+            r#"
+struct A {
+    a: &'static str
+}
+fn main() {
+    let a = "haha";
+    A {
+        a: a
+    }
+}
+        "#,
+            r#"
+struct A {
+    a: &'static str
+}
+fn main() {
+    let a = "haha";
+    A {
+        a
+    }
+}
+        "#,
+            check_struct_shorthand_initialization,
+        );
+        check_apply(
+            r#"
+struct A {
+    a: &'static str,
+    b: &'static str
+}
+fn main() {
+    let a = "haha";
+    let b = "bb";
+    A {
+        a: a,
+        b
+    }
+}
+        "#,
+            r#"
+struct A {
+    a: &'static str,
+    b: &'static str
+}
+fn main() {
+    let a = "haha";
+    let b = "bb";
+    A {
+        a,
+        b
+    }
+}
+        "#,
+            check_struct_shorthand_initialization,
+        );
+    }
+}
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index d9b89155b..a65637d52 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -7,6 +7,7 @@ mod symbols;
 #[cfg(test)]
 mod test_utils;
 mod typing;
+mod diagnostics;
 pub use self::{
    code_actions::{add_derive, add_impl, flip_comma, introduce_variable, make_pub_crate, LocalEdit},
@@ -16,17 +17,17 @@ pub use self::{
    line_index_utils::translate_offset_with_edit,
    symbols::{file_structure, file_symbols, FileSymbol, StructureNode},
    typing::{join_lines, on_enter, on_eq_typed},
+    diagnostics::diagnostics
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
 use ra_syntax::{
    algo::find_leaf_at_offset,
    ast::{self, AstNode, NameOwner},
    SourceFileNode,
-    Location,
    SyntaxKind::{self, *},
-    SyntaxNodeRef, TextRange, TextUnit,
+    SyntaxNodeRef, TextRange, TextUnit, Direction,
 };
-use itertools::Itertools;
+use rustc_hash::FxHashSet;
 #[derive(Debug)]
 pub struct HighlightedRange {
@@ -79,8 +80,13 @@ pub fn matching_brace(file: &SourceFileNode, offset: TextUnit) -> Option<TextUni
 }
 pub fn highlight(file: &SourceFileNode) -> Vec<HighlightedRange> {
+    // Visited nodes to handle highlighting priorities
+    let mut highlighted = FxHashSet::default();
    let mut res = Vec::new();
    for node in file.syntax().descendants() {
+        if highlighted.contains(&node) {
+            continue;
+        }
        let tag = match node.kind() {
            COMMENT => "comment",
            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
@@ -90,7 +96,30 @@ pub fn highlight(file: &SourceFileNode) -> Vec<HighlightedRange> {
            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
            LIFETIME => "parameter",
            k if k.is_keyword() => "keyword",
-            _ => continue,
+            _ => {
+                if let Some(macro_call) = ast::MacroCall::cast(node) {
+                    if let Some(path) = macro_call.path() {
+                        if let Some(segment) = path.segment() {
+                            if let Some(name_ref) = segment.name_ref() {
+                                highlighted.insert(name_ref.syntax());
+                                let range_start = name_ref.syntax().range().start();
+                                let mut range_end = name_ref.syntax().range().end();
+                                for sibling in path.syntax().siblings(Direction::Next) {
+                                    match sibling.kind() {
+                                        EXCL | IDENT => range_end = sibling.range().end(),
+                                        _ => (),
+                                    }
+                                }
+                                res.push(HighlightedRange {
+                                    range: TextRange::from_to(range_start, range_end),
+                                    tag: "macro",
+                                })
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
        };
        res.push(HighlightedRange {
            range: node.range(),
@@ -100,87 +129,6 @@ pub fn highlight(file: &SourceFileNode) -> Vec<HighlightedRange> {
    res
 }
-pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
-    fn location_to_range(location: Location) -> TextRange {
-        match location {
-            Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
-            Location::Range(range) => range,
-        }
-    }
-    let mut errors: Vec<Diagnostic> = file
-        .errors()
-        .into_iter()
-        .map(|err| Diagnostic {
-            range: location_to_range(err.location()),
-            msg: format!("Syntax Error: {}", err),
-            severity: Severity::Error,
-            fix: None,
-        })
-        .collect();
-    let warnings = check_unnecessary_braces_in_use_statement(file);
-    errors.extend(warnings);
-    errors
-}
-fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagnostic> {
-    let mut diagnostics = Vec::new();
-    for node in file.syntax().descendants() {
-        if let Some(use_tree_list) = ast::UseTreeList::cast(node) {
-            if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
-                let range = use_tree_list.syntax().range();
-                let edit = text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
-                    single_use_tree,
-                )
-                .unwrap_or_else(|| {
-                    let to_replace = single_use_tree.syntax().text().to_string();
-                    let mut edit_builder = TextEditBuilder::new();
-                    edit_builder.delete(range);
-                    edit_builder.insert(range.start(), to_replace);
-                    edit_builder.finish()
-                });
-                diagnostics.push(Diagnostic {
-                    range: range,
-                    msg: format!("Unnecessary braces in use statement"),
-                    severity: Severity::WeakWarning,
-                    fix: Some(LocalEdit {
-                        label: "Remove unnecessary braces".to_string(),
-                        edit: edit,
-                        cursor_position: None,
-                    }),
-                })
-            }
-        }
-    }
-    diagnostics
-}
-fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
-    single_use_tree: ast::UseTree,
-) -> Option<TextEdit> {
-    let use_tree_list_node = single_use_tree.syntax().parent()?;
-    if single_use_tree
-        .path()?
-        .segment()?
-        .syntax()
-        .first_child()?
-        .kind()
-        == SyntaxKind::SELF_KW
-    {
-        let start = use_tree_list_node.prev_sibling()?.range().start();
-        let end = use_tree_list_node.range().end();
-        let range = TextRange::from_to(start, end);
-        let mut edit_builder = TextEditBuilder::new();
-        edit_builder.delete(range);
-        return Some(edit_builder.finish());
-    }
-    None
-}
 pub fn syntax_tree(file: &SourceFileNode) -> String {
    ::ra_syntax::utils::dump_tree(file.syntax())
 }
@@ -235,7 +183,7 @@ fn main() {}
            r#"[HighlightedRange { range: [1; 11), tag: "comment" },
                HighlightedRange { range: [12; 14), tag: "keyword" },
                HighlightedRange { range: [15; 19), tag: "function" },
-                HighlightedRange { range: [29; 36), tag: "text" },
+                HighlightedRange { range: [29; 37), tag: "macro" },
                HighlightedRange { range: [38; 50), tag: "string" },
                HighlightedRange { range: [52; 54), tag: "literal" }]"#,
            &hls,
@@ -281,33 +229,4 @@ fn test_foo() {}
        do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }");
    }
-    #[test]
-    fn test_check_unnecessary_braces_in_use_statement() {
-        fn check_not_applicable(code: &str) {
-            let file = SourceFileNode::parse(code);
-            let diagnostics = check_unnecessary_braces_in_use_statement(&file);
-            assert!(diagnostics.is_empty());
-        }
-        fn check_apply(before: &str, after: &str) {
-            let file = SourceFileNode::parse(before);
-            let diagnostic = check_unnecessary_braces_in_use_statement(&file)
-                .pop()
-                .unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
-            let fix = diagnostic.fix.unwrap();
-            let actual = fix.edit.apply(&before);
-            assert_eq_text!(after, &actual);
-        }
-        check_not_applicable(
-            "
-            use a;
-            use a::{c, d::e};
-        ",
-        );
-        check_apply("use {b};", "use b;");
-        check_apply("use a::{c};", "use a::c;");
-        check_apply("use a::{self};", "use a;");
-        check_apply("use a::{c, d::{e}};", "use a::{c, d::e};");
-    }
 }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 594176337..c3fbd327d 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -5,13 +5,14 @@ version = "0.1.0"
 authors = ["Aleksey Kladov <[email protected]>"]
 [dependencies]
-arrayvec = "0.4.9"
+arrayvec = "0.4.10"
 log = "0.4.5"
 relative-path = "0.4.0"
-salsa = "0.8.0"
+salsa = "0.9.0"
 rustc-hash = "1.0"
-parking_lot = "0.6.4"
+parking_lot = "0.7.0"
 id-arena = "2.0"
+ena = "0.11"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 65c461148..e839a5a90 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -1,10 +1,10 @@
 use std::sync::Arc;
-use ra_syntax::{SmolStr, ast::{self, NameOwner, StructFlavor}};
+use ra_syntax::ast::{self, NameOwner, StructFlavor};
 use crate::{
-    DefId, Cancelable,
+    DefId, Cancelable, Name, AsName,
-    db::{HirDatabase},
+    db::HirDatabase,
    type_ref::TypeRef,
 };
@@ -29,26 +29,26 @@ impl Struct {
        Ok(db.struct_data(self.def_id)?)
    }
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<SmolStr>> {
+    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
        Ok(db.struct_data(self.def_id)?.name.clone())
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StructData {
-    name: Option<SmolStr>,
+    name: Option<Name>,
    variant_data: Arc<VariantData>,
 }
 impl StructData {
    pub(crate) fn new(struct_def: ast::StructDef) -> StructData {
-        let name = struct_def.name().map(|n| n.text());
+        let name = struct_def.name().map(|n| n.as_name());
        let variant_data = VariantData::new(struct_def.flavor());
        let variant_data = Arc::new(variant_data);
        StructData { name, variant_data }
    }
-    pub fn name(&self) -> Option<&SmolStr> {
+    pub fn name(&self) -> Option<&Name> {
        self.name.as_ref()
    }
@@ -70,27 +70,29 @@ impl Enum {
        self.def_id
    }
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<SmolStr>> {
+    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
        Ok(db.enum_data(self.def_id)?.name.clone())
    }
+    pub fn variants(&self, db: &impl HirDatabase) -> Cancelable<Vec<(Name, Arc<VariantData>)>> {
+        Ok(db.enum_data(self.def_id)?.variants.clone())
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumData {
-    name: Option<SmolStr>,
+    name: Option<Name>,
-    variants: Vec<(SmolStr, Arc<VariantData>)>,
+    variants: Vec<(Name, Arc<VariantData>)>,
 }
 impl EnumData {
    pub(crate) fn new(enum_def: ast::EnumDef) -> Self {
-        let name = enum_def.name().map(|n| n.text());
+        let name = enum_def.name().map(|n| n.as_name());
        let variants = if let Some(evl) = enum_def.variant_list() {
            evl.variants()
                .map(|v| {
                    (
-                        v.name()
+                        v.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
-                            .map(|n| n.text())
-                            .unwrap_or_else(|| SmolStr::new("[error]")),
                        Arc::new(VariantData::new(v.flavor())),
                    )
                })
@@ -105,12 +107,12 @@ impl EnumData {
 /// A single field of an enum variant or struct
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StructField {
-    name: SmolStr,
+    name: Name,
    type_ref: TypeRef,
 }
 impl StructField {
-    pub fn name(&self) -> SmolStr {
+    pub fn name(&self) -> Name {
        self.name.clone()
    }
    pub fn type_ref(&self) -> &TypeRef {
@@ -134,7 +136,7 @@ impl VariantData {
                    .fields()
                    .enumerate()
                    .map(|(i, fd)| StructField {
-                        name: SmolStr::new(i.to_string()),
+                        name: Name::tuple_field_name(i),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
                    })
                    .collect();
@@ -144,10 +146,7 @@ impl VariantData {
                let fields = fl
                    .fields()
                    .map(|fd| StructField {
-                        name: fd
+                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
-                            .name()
-                            .map(|n| n.text())
-                            .unwrap_or_else(|| SmolStr::new("[error]")),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
                    })
                    .collect();
@@ -157,10 +156,10 @@ impl VariantData {
        }
    }
-    pub(crate) fn get_field_type_ref(&self, field_name: &str) -> Option<&TypeRef> {
+    pub(crate) fn get_field_type_ref(&self, field_name: &Name) -> Option<&TypeRef> {
        self.fields()
            .iter()
-            .find(|f| f.name == field_name)
+            .find(|f| f.name == *field_name)
            .map(|f| &f.type_ref)
    }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index e7f9afa77..5a8ca3b47 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,18 +1,13 @@
 use std::sync::Arc;
-use ra_syntax::{
+use ra_syntax::SyntaxNode;
-    SmolStr,
-    SyntaxNode,
-    ast::FnDefNode,
-};
 use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, FileId, Cancelable};
 use crate::{
-    DefLoc, DefId,
+    DefLoc, DefId, Name,
    SourceFileItems, SourceItemId,
    query_definitions,
    FnScopes,
-    function::FnId,
    module::{ModuleId, ModuleTree, ModuleSource,
    nameres::{ItemMap, InputModuleItems}},
    ty::{InferenceResult, Ty},
@@ -24,14 +19,10 @@ salsa::query_group! {
 pub trait HirDatabase: SyntaxDatabase
    + AsRef<LocationIntener<DefLoc, DefId>>
 {
-    fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
+    fn fn_scopes(def_id: DefId) -> Arc<FnScopes> {
        type FnScopesQuery;
        use fn query_definitions::fn_scopes;
    }
-    fn fn_syntax(fn_id: FnId) -> FnDefNode {
-        type FnSyntaxQuery;
-        use fn query_definitions::fn_syntax;
-    }
    fn struct_data(def_id: DefId) -> Cancelable<Arc<StructData>> {
        type StructDataQuery;
@@ -43,19 +34,19 @@ pub trait HirDatabase: SyntaxDatabase
        use fn query_definitions::enum_data;
    }
-    fn infer(fn_id: FnId) -> Cancelable<Arc<InferenceResult>> {
+    fn infer(def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
        type InferQuery;
-        use fn query_definitions::infer;
+        use fn crate::ty::infer;
    }
    fn type_for_def(def_id: DefId) -> Cancelable<Ty> {
        type TypeForDefQuery;
-        use fn query_definitions::type_for_def;
+        use fn crate::ty::type_for_def;
    }
-    fn type_for_field(def_id: DefId, field: SmolStr) -> Cancelable<Ty> {
+    fn type_for_field(def_id: DefId, field: Name) -> Cancelable<Ty> {
        type TypeForFieldQuery;
-        use fn query_definitions::type_for_field;
+        use fn crate::ty::type_for_field;
    }
    fn file_items(file_id: FileId) -> Arc<SourceFileItems> {
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 01f0f3a66..5a44132fc 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -11,42 +11,42 @@ use ra_syntax::{
    ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
-use crate::{ DefId, HirDatabase, ty::InferenceResult, Module };
+use crate::{DefId, DefKind, HirDatabase, ty::InferenceResult, Module};
 pub use self::scope::FnScopes;
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Debug)]
-pub struct FnId(pub(crate) DefId);
 pub struct Function {
-    pub(crate) fn_id: FnId,
+    def_id: DefId,
 }
 impl Function {
    pub(crate) fn new(def_id: DefId) -> Function {
-        let fn_id = FnId(def_id);
+        Function { def_id }
-        Function { fn_id }
    }
    pub fn syntax(&self, db: &impl HirDatabase) -> ast::FnDefNode {
-        db.fn_syntax(self.fn_id)
+        let def_loc = self.def_id.loc(db);
+        assert!(def_loc.kind == DefKind::Function);
+        let syntax = db.file_item(def_loc.source_item_id);
+        ast::FnDef::cast(syntax.borrowed()).unwrap().owned()
    }
    pub fn scopes(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
-        db.fn_scopes(self.fn_id)
+        db.fn_scopes(self.def_id)
    }
    pub fn signature_info(&self, db: &impl HirDatabase) -> Option<FnSignatureInfo> {
-        let syntax = db.fn_syntax(self.fn_id);
+        let syntax = self.syntax(db);
        FnSignatureInfo::new(syntax.borrowed())
    }
    pub fn infer(&self, db: &impl HirDatabase) -> Cancelable<Arc<InferenceResult>> {
-        db.infer(self.fn_id)
+        db.infer(self.def_id)
    }
    pub fn module(&self, db: &impl HirDatabase) -> Cancelable<Module> {
-        self.fn_id.0.module(db)
+        self.def_id.module(db)
    }
 }
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index a1a580979..3e4cfad0c 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,7 +1,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
-    AstNode, SmolStr, SyntaxNodeRef, TextUnit, TextRange,
+    AstNode, SyntaxNodeRef, TextUnit, TextRange,
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
 };
@@ -9,6 +9,7 @@ use ra_db::LocalSyntaxPtr;
 use crate::{
    arena::{Arena, Id},
+    Name, AsName,
 };
 pub(crate) type ScopeId = Id<ScopeData>;
@@ -22,7 +23,7 @@ pub struct FnScopes {
 #[derive(Debug, PartialEq, Eq)]
 pub struct ScopeEntry {
-    name: SmolStr,
+    name: Name,
    ptr: LocalSyntaxPtr,
 }
@@ -101,11 +102,12 @@ impl FnScopes {
    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
        let mut shadowed = FxHashSet::default();
+        let name = name_ref.as_name();
        let ret = self
            .scope_chain(name_ref.syntax())
            .flat_map(|scope| self.entries(scope).iter())
            .filter(|entry| shadowed.insert(entry.name()))
-            .filter(|entry| entry.name() == &name_ref.text())
+            .filter(|entry| entry.name() == &name)
            .nth(0);
        ret
    }
@@ -170,14 +172,14 @@ impl FnScopes {
 impl ScopeEntry {
    fn new(pat: ast::BindPat) -> Option<ScopeEntry> {
-        let name = pat.name()?;
+        let name = pat.name()?.as_name();
        let res = ScopeEntry {
-            name: name.text(),
+            name,
            ptr: LocalSyntaxPtr::new(pat.syntax()),
        };
        Some(res)
    }
-    pub fn name(&self) -> &SmolStr {
+    pub fn name(&self) -> &Name {
        &self.name
    }
    pub fn ptr(&self) -> LocalSyntaxPtr {
@@ -334,7 +336,7 @@ pub struct ReferenceDescriptor {
 mod tests {
    use ra_editor::find_node_at_offset;
    use ra_syntax::SourceFileNode;
-    use test_utils::extract_offset;
+    use test_utils::{extract_offset, assert_eq_text};
    use super::*;
@@ -355,9 +357,11 @@ mod tests {
        let actual = scopes
            .scope_chain(marker.syntax())
            .flat_map(|scope| scopes.entries(scope))
-            .map(|it| it.name())
+            .map(|it| it.name().to_string())
-            .collect::<Vec<_>>();
+            .collect::<Vec<_>>()
-        assert_eq!(actual.as_slice(), expected);
+            .join("\n");
+        let expected = expected.join("\n");
+        assert_eq_text!(&actual, &expected);
    }
    #[test]
diff --git a/crates/ra_hir/src/krate.rs b/crates/ra_hir/src/krate.rs
index 1196dcef1..89b1e639e 100644
--- a/crates/ra_hir/src/krate.rs
+++ b/crates/ra_hir/src/krate.rs
@@ -1,7 +1,6 @@
-use ra_syntax::SmolStr;
 pub use ra_db::CrateId;
-use crate::{HirDatabase, Module, Cancelable};
+use crate::{HirDatabase, Module, Cancelable, Name, AsName};
 /// hir::Crate describes a single crate. It's the main inteface with which
 /// crate's dependencies interact. Mostly, it should be just a proxy for the
@@ -14,7 +13,7 @@ pub struct Crate {
 #[derive(Debug)]
 pub struct CrateDependency {
    pub krate: Crate,
-    pub name: SmolStr,
+    pub name: Name,
 }
 impl Crate {
@@ -27,7 +26,7 @@ impl Crate {
            .dependencies(self.crate_id)
            .map(|dep| {
                let krate = Crate::new(dep.crate_id());
-                let name = dep.name.clone();
+                let name = dep.as_name();
                CrateDependency { krate, name }
            })
            .collect()
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index f1cc0ccd0..5bbb09c01 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -22,6 +22,7 @@ mod path;
 mod arena;
 pub mod source_binder;
+mod name;
 mod krate;
 mod module;
 mod function;
@@ -37,10 +38,12 @@ use ra_db::{LocationIntener, SourceRootId, FileId, Cancelable};
 use crate::{
    db::HirDatabase,
    arena::{Arena, Id},
+    name::{AsName, KnownName},
 };
 pub use self::{
    path::{Path, PathKind},
+    name::Name,
    krate::Crate,
    module::{Module, ModuleId, Problem, nameres::{ItemMap, PerNs, Namespace}, ModuleScope, Resolution},
    function::{Function, FnScopes},
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index f6882cb77..a2507c9b5 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -189,7 +189,6 @@ salsa::database_storage! {
            fn file_item() for db::FileItemQuery;
            fn input_module_items() for db::InputModuleItemsQuery;
            fn item_map() for db::ItemMapQuery;
-            fn fn_syntax() for db::FnSyntaxQuery;
            fn submodules() for db::SubmodulesQuery;
            fn infer() for db::InferQuery;
            fn type_for_def() for db::TypeForDefQuery;
diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs
index b9d36f01f..24c346984 100644
--- a/crates/ra_hir/src/module.rs
+++ b/crates/ra_hir/src/module.rs
@@ -7,13 +7,14 @@ use log;
 use ra_syntax::{
    algo::generate,
    ast::{self, AstNode, NameOwner},
-    SmolStr, SyntaxNode,
+    SyntaxNode,
 };
 use ra_db::{SourceRootId, FileId, Cancelable};
 use relative_path::RelativePathBuf;
 use crate::{
-    DefKind, DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId, Crate,
+    Def, DefKind, DefLoc, DefId,
+    Name, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId, Crate,
    arena::{Arena, Id},
 };
@@ -84,7 +85,7 @@ impl Module {
    }
    /// `name` is `None` for the crate's root module
-    pub fn name(&self) -> Option<SmolStr> {
+    pub fn name(&self) -> Option<&Name> {
        let link = self.module_id.parent_link(&self.tree)?;
        Some(link.name(&self.tree))
    }
@@ -100,7 +101,7 @@ impl Module {
    }
    /// Finds a child module with the specified name.
-    pub fn child(&self, name: &str) -> Option<Module> {
+    pub fn child(&self, name: &Name) -> Option<Module> {
        let child_id = self.module_id.child(&self.tree, name)?;
        Some(Module {
            module_id: child_id,
@@ -138,13 +139,8 @@ impl Module {
            } else {
                return Ok(PerNs::none());
            };
-            let module = match curr.loc(db) {
+            let module = match curr.resolve(db)? {
-                DefLoc {
+                Def::Module(it) => it,
-                    kind: DefKind::Module,
-                    source_root_id,
-                    module_id,
-                    ..
-                } => Module::new(db, source_root_id, module_id)?,
                // TODO here would be the place to handle enum variants...
                _ => return Ok(PerNs::none()),
            };
@@ -230,15 +226,15 @@ impl ModuleId {
            .last()
            .unwrap()
    }
-    fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
+    fn child(self, tree: &ModuleTree, name: &Name) -> Option<ModuleId> {
        let link = tree.mods[self]
            .children
            .iter()
            .map(|&it| &tree.links[it])
-            .find(|it| it.name == name)?;
+            .find(|it| it.name == *name)?;
        Some(*link.points_to.first()?)
    }
-    fn children<'a>(self, tree: &'a ModuleTree) -> impl Iterator<Item = (SmolStr, ModuleId)> + 'a {
+    fn children<'a>(self, tree: &'a ModuleTree) -> impl Iterator<Item = (Name, ModuleId)> + 'a {
        tree.mods[self].children.iter().filter_map(move |&it| {
            let link = &tree.links[it];
            let module = *link.points_to.first()?;
@@ -263,8 +259,8 @@ impl LinkId {
    fn owner(self, tree: &ModuleTree) -> ModuleId {
        tree.links[self].owner
    }
-    fn name(self, tree: &ModuleTree) -> SmolStr {
+    fn name(self, tree: &ModuleTree) -> &Name {
-        tree.links[self].name.clone()
+        &tree.links[self].name
    }
    fn bind_source<'a>(self, tree: &ModuleTree, db: &impl HirDatabase) -> ast::ModuleNode {
        let owner = self.owner(tree);
@@ -328,7 +324,7 @@ impl ModuleSource {
 #[derive(Hash, Debug, PartialEq, Eq)]
 struct LinkData {
    owner: ModuleId,
-    name: SmolStr,
+    name: Name,
    points_to: Vec<ModuleId>,
    problem: Option<Problem>,
 }
diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index 748fdb64e..eded85a63 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -1,16 +1,13 @@
 use std::sync::Arc;
-use ra_syntax::{
+use ra_syntax::ast::{self, NameOwner};
-    ast::{self, NameOwner},
-    SmolStr,
-};
 use relative_path::RelativePathBuf;
 use rustc_hash::{FxHashMap, FxHashSet};
 use arrayvec::ArrayVec;
 use ra_db::{SourceRoot, SourceRootId, Cancelable, FileId};
 use crate::{
-    HirDatabase,
+    HirDatabase, Name, AsName,
 };
 use super::{
@@ -20,12 +17,12 @@ use super::{
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
 pub enum Submodule {
-    Declaration(SmolStr),
+    Declaration(Name),
-    Definition(SmolStr, ModuleSource),
+    Definition(Name, ModuleSource),
 }
 impl Submodule {
-    fn name(&self) -> &SmolStr {
+    fn name(&self) -> &Name {
        match self {
            Submodule::Declaration(name) => name,
            Submodule::Definition(name, _) => name,
@@ -35,14 +32,14 @@ impl Submodule {
 pub(crate) fn modules<'a>(
    root: impl ast::ModuleItemOwner<'a>,
-) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+) -> impl Iterator<Item = (Name, ast::Module<'a>)> {
    root.items()
        .filter_map(|item| match item {
            ast::ModuleItem::Module(m) => Some(m),
            _ => None,
        })
        .filter_map(|module| {
-            let name = module.name()?.text();
+            let name = module.name()?.as_name();
            Some((name, module))
        })
 }
@@ -155,7 +152,7 @@ fn build_subtree(
 fn resolve_submodule(
    db: &impl HirDatabase,
    source: ModuleSource,
-    name: &SmolStr,
+    name: &Name,
 ) -> (Vec<FileId>, Option<Problem>) {
    // FIXME: handle submodules of inline modules properly
    let file_id = source.file_id();
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 98cd225dd..68eb02a98 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -14,14 +14,12 @@
 //! modifications (that is, typing inside a function shold not change IMIs),
 //! such that the results of name resolution can be preserved unless the module
 //! structure itself is modified.
-use std::{
+use std::sync::Arc;
-    sync::Arc,
-};
 use rustc_hash::FxHashMap;
 use ra_syntax::{
    TextRange,
-    SmolStr, SyntaxKind::{self, *},
+    SyntaxKind::{self, *},
    ast::{self, AstNode}
 };
 use ra_db::SourceRootId;
@@ -32,6 +30,7 @@ use crate::{
    SourceItemId, SourceFileItemId, SourceFileItems,
    Path, PathKind,
    HirDatabase, Crate,
+    Name, AsName,
    module::{Module, ModuleId, ModuleTree},
 };
@@ -45,14 +44,14 @@ pub struct ItemMap {
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub struct ModuleScope {
-    items: FxHashMap<SmolStr, Resolution>,
+    items: FxHashMap<Name, Resolution>,
 }
 impl ModuleScope {
-    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &'a Resolution)> + 'a {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, &'a Resolution)> + 'a {
        self.items.iter()
    }
-    pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
+    pub fn get(&self, name: &Name) -> Option<&Resolution> {
        self.items.get(name)
    }
 }
@@ -72,7 +71,7 @@ pub struct InputModuleItems {
 #[derive(Debug, PartialEq, Eq)]
 struct ModuleItem {
    id: SourceFileItemId,
-    name: SmolStr,
+    name: Name,
    kind: SyntaxKind,
    vis: Vis,
 }
@@ -260,7 +259,7 @@ impl InputModuleItems {
 impl ModuleItem {
    fn new<'a>(file_items: &SourceFileItems, item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
-        let name = item.name()?.text();
+        let name = item.name()?.as_name();
        let kind = item.syntax().kind();
        let vis = Vis::Other;
        let id = file_items.id_of_unchecked(item.syntax());
@@ -328,7 +327,11 @@ where
                for dep in krate.dependencies(self.db) {
                    if let Some(module) = dep.krate.root_module(self.db)? {
                        let def_id = module.def_id(self.db);
-                        self.add_module_item(&mut module_items, dep.name, PerNs::types(def_id));
+                        self.add_module_item(
+                            &mut module_items,
+                            dep.name.clone(),
+                            PerNs::types(def_id),
+                        );
                    }
                }
            };
@@ -389,7 +392,7 @@ where
        Ok(())
    }
-    fn add_module_item(&self, module_items: &mut ModuleScope, name: SmolStr, def_id: PerNs<DefId>) {
+    fn add_module_item(&self, module_items: &mut ModuleScope, name: Name, def_id: PerNs<DefId>) {
        let resolution = Resolution {
            def_id,
            import: None,
diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/module/nameres/tests.rs
index 03ea5c1d6..ca20f064f 100644
--- a/crates/ra_hir/src/module/nameres/tests.rs
+++ b/crates/ra_hir/src/module/nameres/tests.rs
@@ -2,8 +2,8 @@ use std::sync::Arc;
 use salsa::Database;
 use ra_db::{FilesDatabase, CrateGraph};
-use ra_syntax::SmolStr;
 use relative_path::RelativePath;
+use test_utils::assert_eq_text;
 use crate::{
    self as hir,
@@ -21,6 +21,35 @@ fn item_map(fixture: &str) -> (Arc<hir::ItemMap>, hir::ModuleId) {
    (db.item_map(source_root).unwrap(), module_id)
 }
+fn check_module_item_map(map: &hir::ItemMap, module_id: hir::ModuleId, expected: &str) {
+    let mut lines = map.per_module[&module_id]
+        .items
+        .iter()
+        .map(|(name, res)| format!("{}: {}", name, dump_resolution(res)))
+        .collect::<Vec<_>>();
+    lines.sort();
+    let actual = lines.join("\n");
+    let expected = expected
+        .trim()
+        .lines()
+        .map(|it| it.trim())
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert_eq_text!(&actual, &expected);
+    fn dump_resolution(resolution: &hir::Resolution) -> &'static str {
+        match (
+            resolution.def_id.types.is_some(),
+            resolution.def_id.values.is_some(),
+        ) {
+            (true, true) => "t v",
+            (true, false) => "t",
+            (false, true) => "v",
+            (false, false) => "_",
+        }
+    }
+}
 #[test]
 fn item_map_smoke_test() {
    let (item_map, module_id) = item_map(
@@ -38,13 +67,18 @@ fn item_map_smoke_test() {
        pub struct Baz;
    ",
    );
-    let name = SmolStr::from("Baz");
+    check_module_item_map(
-    let resolution = &item_map.per_module[&module_id].items[&name];
+        &item_map,
-    assert!(resolution.def_id.take_types().is_some());
+        module_id,
+        "
+            Baz: t v
+            foo: t
+        ",
+    );
 }
 #[test]
-fn test_self() {
+fn item_map_using_self() {
    let (item_map, module_id) = item_map(
        "
            //- /lib.rs
@@ -57,9 +91,14 @@ fn test_self() {
            pub struct Baz;
        ",
    );
-    let name = SmolStr::from("Baz");
+    check_module_item_map(
-    let resolution = &item_map.per_module[&module_id].items[&name];
+        &item_map,
-    assert!(resolution.def_id.take_types().is_some());
+        module_id,
+        "
+            Baz: t v
+            foo: t
+        ",
+    );
 }
 #[test]
@@ -90,9 +129,14 @@ fn item_map_across_crates() {
    let module_id = module.module_id;
    let item_map = db.item_map(source_root).unwrap();
-    let name = SmolStr::from("Baz");
+    check_module_item_map(
-    let resolution = &item_map.per_module[&module_id].items[&name];
+        &item_map,
-    assert!(resolution.def_id.take_types().is_some());
+        module_id,
+        "
+            Baz: t v
+            test_crate: t
+        ",
+    );
 }
 #[test]
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
new file mode 100644
index 000000000..51e8b3da8
--- /dev/null
+++ b/crates/ra_hir/src/name.rs
@@ -0,0 +1,105 @@
+use std::fmt;
+use ra_syntax::{ast, SmolStr};
+/// `Name` is a wrapper around string, which is used in hir for both references
+/// and declarations. In theory, names should also carry hygene info, but we are
+/// not there yet!
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Name {
+    text: SmolStr,
+}
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.text, f)
+    }
+}
+impl fmt::Debug for Name {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.text, f)
+    }
+}
+impl Name {
+    fn new(text: SmolStr) -> Name {
+        Name { text }
+    }
+    pub(crate) fn missing() -> Name {
+        Name::new("[missing name]".into())
+    }
+    pub(crate) fn tuple_field_name(idx: usize) -> Name {
+        Name::new(idx.to_string().into())
+    }
+    pub(crate) fn as_known_name(&self) -> Option<KnownName> {
+        let name = match self.text.as_str() {
+            "isize" => KnownName::Isize,
+            "i8" => KnownName::I8,
+            "i16" => KnownName::I16,
+            "i32" => KnownName::I32,
+            "i64" => KnownName::I64,
+            "i128" => KnownName::I128,
+            "usize" => KnownName::Usize,
+            "u8" => KnownName::U8,
+            "u16" => KnownName::U16,
+            "u32" => KnownName::U32,
+            "u64" => KnownName::U64,
+            "u128" => KnownName::U128,
+            "f32" => KnownName::F32,
+            "f64" => KnownName::F64,
+            _ => return None,
+        };
+        Some(name)
+    }
+}
+pub(crate) trait AsName {
+    fn as_name(&self) -> Name;
+}
+impl AsName for ast::NameRef<'_> {
+    fn as_name(&self) -> Name {
+        Name::new(self.text())
+    }
+}
+impl AsName for ast::Name<'_> {
+    fn as_name(&self) -> Name {
+        Name::new(self.text())
+    }
+}
+impl AsName for ra_db::Dependency {
+    fn as_name(&self) -> Name {
+        Name::new(self.name.clone())
+    }
+}
+// Ideally, should be replaced with
+// ```
+// const ISIZE: Name = Name::new("isize")
+// ```
+// but const-fn is not that powerful yet.
+#[derive(Debug)]
+pub(crate) enum KnownName {
+    Isize,
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+    F32,
+    F64,
+}
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 0b260072c..93f7203fe 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -1,9 +1,11 @@
-use ra_syntax::{SmolStr, ast, AstNode, TextRange};
+use ra_syntax::{ast, AstNode, TextRange};
+use crate::{Name, AsName};
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
    pub kind: PathKind,
-    pub segments: Vec<SmolStr>,
+    pub segments: Vec<Name>,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -29,7 +31,7 @@ impl Path {
        loop {
            let segment = path.segment()?;
            match segment.kind()? {
-                ast::PathSegmentKind::Name(name) => segments.push(name.text()),
+                ast::PathSegmentKind::Name(name) => segments.push(name.as_name()),
                ast::PathSegmentKind::CrateKw => {
                    kind = PathKind::Crate;
                    break;
@@ -67,6 +69,14 @@ impl Path {
    pub fn is_ident(&self) -> bool {
        self.kind == PathKind::Plain && self.segments.len() == 1
    }
+    /// If this path is a single identifier, like `foo`, return its name.
+    pub fn as_ident(&self) -> Option<&Name> {
+        if self.kind != PathKind::Plain || self.segments.len() > 1 {
+            return None;
+        }
+        self.segments.first()
+    }
 }
 fn expand_use_tree(
@@ -130,7 +140,7 @@ fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
                kind: PathKind::Plain,
                segments: Vec::with_capacity(1),
            });
-            res.segments.push(name.text());
+            res.segments.push(name.as_name());
            res
        }
        ast::PathSegmentKind::CrateKw => {
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index 4a7958a12..721bd4195 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -5,55 +5,30 @@ use std::{
 use rustc_hash::FxHashMap;
 use ra_syntax::{
-    AstNode,  SyntaxNode, SmolStr,
+    AstNode, SyntaxNode,
-    ast::{self, FnDef, FnDefNode, NameOwner, ModuleItemOwner}
+    ast::{self, NameOwner, ModuleItemOwner}
 };
 use ra_db::{SourceRootId, FileId, Cancelable,};
 use crate::{
-    SourceFileItems, SourceItemId, DefKind, Function, DefId,
+    SourceFileItems, SourceItemId, DefKind, Function, DefId, Name, AsName,
    db::HirDatabase,
-    function::{FnScopes, FnId},
+    function::FnScopes,
    module::{
        ModuleSource, ModuleSourceNode, ModuleId,
        imp::Submodule,
        nameres::{InputModuleItems, ItemMap, Resolver},
    },
-    ty::{self, InferenceResult, Ty},
    adt::{StructData, EnumData},
 };
-/// Resolve `FnId` to the corresponding `SyntaxNode`
+pub(super) fn fn_scopes(db: &impl HirDatabase, def_id: DefId) -> Arc<FnScopes> {
-pub(super) fn fn_syntax(db: &impl HirDatabase, fn_id: FnId) -> FnDefNode {
+    let function = Function::new(def_id);
-    let def_loc = fn_id.0.loc(db);
+    let syntax = function.syntax(db);
-    assert!(def_loc.kind == DefKind::Function);
-    let syntax = db.file_item(def_loc.source_item_id);
-    FnDef::cast(syntax.borrowed()).unwrap().owned()
-}
-pub(super) fn fn_scopes(db: &impl HirDatabase, fn_id: FnId) -> Arc<FnScopes> {
-    let syntax = db.fn_syntax(fn_id);
    let res = FnScopes::new(syntax.borrowed());
    Arc::new(res)
 }
-pub(super) fn infer(db: &impl HirDatabase, fn_id: FnId) -> Cancelable<Arc<InferenceResult>> {
-    let function = Function { fn_id };
-    ty::infer(db, function).map(Arc::new)
-}
-pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
-    ty::type_for_def(db, def_id)
-}
-pub(super) fn type_for_field(
-    db: &impl HirDatabase,
-    def_id: DefId,
-    field: SmolStr,
-) -> Cancelable<Ty> {
-    ty::type_for_field(db, def_id, field)
-}
 pub(super) fn struct_data(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<StructData>> {
    let def_loc = def_id.loc(db);
    assert!(def_loc.kind == DefKind::Struct);
@@ -130,14 +105,14 @@ pub(crate) fn submodules(
 pub(crate) fn modules<'a>(
    root: impl ast::ModuleItemOwner<'a>,
-) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+) -> impl Iterator<Item = (Name, ast::Module<'a>)> {
    root.items()
        .filter_map(|item| match item {
            ast::ModuleItem::Module(m) => Some(m),
            _ => None,
        })
        .filter_map(|module| {
-            let name = module.name()?.text();
+            let name = module.name()?.as_name();
            Some((name, module))
        })
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index a0165aef2..a0d1daf71 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -8,14 +8,14 @@
 use ra_db::{FileId, FilePosition, Cancelable};
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    ast::{self, AstNode},
+    ast::{self, AstNode, NameOwner},
    SyntaxNodeRef,
 };
 use crate::{
    HirDatabase, Module, Function, SourceItemId,
    module::ModuleSource,
-    DefKind, DefLoc
+    DefKind, DefLoc, AsName,
 };
 /// Locates the module by `FileId`. Picks topmost module in the file.
@@ -24,6 +24,25 @@ pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable
    module_from_source(db, module_source)
 }
+/// Locates the child module by `mod child;` declaration.
+pub fn module_from_declaration(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    decl: ast::Module,
+) -> Cancelable<Option<Module>> {
+    let parent_module = module_from_file_id(db, file_id)?;
+    let child_name = decl.name();
+    match (parent_module, child_name) {
+        (Some(parent_module), Some(child_name)) => {
+            if let Some(child) = parent_module.child(&child_name.as_name()) {
+                return Ok(Some(child));
+            }
+        }
+        _ => (),
+    }
+    Ok(None)
+}
 /// Locates the module by position in the source code.
 pub fn module_from_position(
    db: &impl HirDatabase,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 67b523c2c..719b3f7cd 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -1,27 +1,133 @@
+//! The type system. We currently use this to infer types for completion.
+//!
+//! For type inference, compare the implementations in rustc (the various
+//! check_* methods in librustc_typeck/check/mod.rs are a good entry point) and
+//! IntelliJ-Rust (org.rust.lang.core.types.infer). Our entry point for
+//! inference here is the `infer` function, which infers the types of all
+//! expressions in a given function.
+//!
+//! The central struct here is `Ty`, which represents a type. During inference,
+//! it can contain type 'variables' which represent currently unknown types; as
+//! we walk through the expressions, we might determine that certain variables
+//! need to be equal to each other, or to certain types. To record this, we use
+//! the union-find implementation from the `ena` crate, which is extracted from
+//! rustc.
 mod primitive;
 #[cfg(test)]
 mod tests;
 use std::sync::Arc;
-use std::fmt;
+use std::{fmt, mem};
 use log;
-use rustc_hash::{FxHashMap};
+use rustc_hash::FxHashMap;
+use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
 use ra_db::{LocalSyntaxPtr, Cancelable};
 use ra_syntax::{
-    SmolStr,
    ast::{self, AstNode, LoopBodyOwner, ArgListOwner, PrefixOp},
    SyntaxNodeRef
 };
 use crate::{
-    Def, DefId, FnScopes, Module, Function, Struct, Enum, Path,
+    Def, DefId, FnScopes, Module, Function, Struct, Enum, Path, Name, AsName,
    db::HirDatabase,
-    adt::VariantData,
    type_ref::{TypeRef, Mutability},
 };
+/// The ID of a type variable.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct TypeVarId(u32);
+impl UnifyKey for TypeVarId {
+    type Value = TypeVarValue;
+    fn index(&self) -> u32 {
+        self.0
+    }
+    fn from_index(i: u32) -> Self {
+        TypeVarId(i)
+    }
+    fn tag() -> &'static str {
+        "TypeVarId"
+    }
+}
+/// The value of a type variable: either we already know the type, or we don't
+/// know it yet.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum TypeVarValue {
+    Known(Ty),
+    Unknown,
+}
+impl TypeVarValue {
+    fn known(&self) -> Option<&Ty> {
+        match self {
+            TypeVarValue::Known(ty) => Some(ty),
+            TypeVarValue::Unknown => None,
+        }
+    }
+}
+impl UnifyValue for TypeVarValue {
+    type Error = NoError;
+    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, NoError> {
+        match (value1, value2) {
+            // We should never equate two type variables, both of which have
+            // known types. Instead, we recursively equate those types.
+            (TypeVarValue::Known(..), TypeVarValue::Known(..)) => {
+                panic!("equating two type variables, both of which have known types")
+            }
+            // If one side is known, prefer that one.
+            (TypeVarValue::Known(..), TypeVarValue::Unknown) => Ok(value1.clone()),
+            (TypeVarValue::Unknown, TypeVarValue::Known(..)) => Ok(value2.clone()),
+            (TypeVarValue::Unknown, TypeVarValue::Unknown) => Ok(TypeVarValue::Unknown),
+        }
+    }
+}
+/// The kinds of placeholders we need during type inference. Currently, we only
+/// have type variables; in the future, we will probably also need int and float
+/// variables, for inference of literal values (e.g. `100` could be one of
+/// several integer types).
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub enum InferTy {
+    TypeVar(TypeVarId),
+}
+/// When inferring an expression, we propagate downward whatever type hint we
+/// are able in the form of an `Expectation`.
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct Expectation {
+    ty: Ty,
+    // TODO: In some cases, we need to be aware whether the expectation is that
+    // the type match exactly what we passed, or whether it just needs to be
+    // coercible to the expected type. See Expectation::rvalue_hint in rustc.
+}
+impl Expectation {
+    /// The expectation that the type of the expression needs to equal the given
+    /// type.
+    fn has_type(ty: Ty) -> Self {
+        Expectation { ty }
+    }
+    /// This expresses no expectation on the type.
+    fn none() -> Self {
+        Expectation { ty: Ty::Unknown }
+    }
+}
+/// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs).
+///
+/// This should be cheap to clone.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum Ty {
    /// The primitive boolean type. Written as `bool`.
@@ -45,7 +151,7 @@ pub enum Ty {
        /// The DefId of the struct/enum.
        def_id: DefId,
        /// The name, for displaying.
-        name: SmolStr,
+        name: Name,
        // later we'll need generic substitutions here
    },
@@ -55,14 +161,14 @@ pub enum Ty {
    // An array with the given length. Written as `[T; n]`.
    // Array(Ty, ty::Const),
    /// The pointee of an array slice.  Written as `[T]`.
-    Slice(TyRef),
+    Slice(Arc<Ty>),
    /// A raw pointer. Written as `*mut T` or `*const T`
-    RawPtr(TyRef, Mutability),
+    RawPtr(Arc<Ty>, Mutability),
    /// A reference; a pointer with an associated lifetime. Written as
    /// `&'a mut T` or `&'a T`.
-    Ref(TyRef, Mutability),
+    Ref(Arc<Ty>, Mutability),
    /// A pointer to a function.  Written as `fn() -> i32`.
    ///
@@ -74,52 +180,51 @@ pub enum Ty {
    /// ```
    FnPtr(Arc<FnSig>),
+    // rustc has a separate type for each function, which just coerces to the
+    // above function pointer type. Once we implement generics, we will probably
+    // need this as well.
    // A trait, defined with `dyn trait`.
    // Dynamic(),
-    /// The anonymous type of a closure. Used to represent the type of
+    // The anonymous type of a closure. Used to represent the type of
-    /// `|a| a`.
+    // `|a| a`.
    // Closure(DefId, ClosureSubsts<'tcx>),
-    /// The anonymous type of a generator. Used to represent the type of
+    // The anonymous type of a generator. Used to represent the type of
-    /// `|a| yield a`.
+    // `|a| yield a`.
    // Generator(DefId, GeneratorSubsts<'tcx>, hir::GeneratorMovability),
-    /// A type representin the types stored inside a generator.
+    // A type representin the types stored inside a generator.
-    /// This should only appear in GeneratorInteriors.
+    // This should only appear in GeneratorInteriors.
    // GeneratorWitness(Binder<&'tcx List<Ty<'tcx>>>),
+    /// The never type `!`.
-    /// The never type `!`
    Never,
    /// A tuple type.  For example, `(i32, bool)`.
-    Tuple(Vec<Ty>),
+    Tuple(Arc<[Ty]>),
    // The projection of an associated type.  For example,
-    // `<T as Trait<..>>::N`.
+    // `<T as Trait<..>>::N`.pub
    // Projection(ProjectionTy),
    // Opaque (`impl Trait`) type found in a return type.
-    // The `DefId` comes either from
-    // * the `impl Trait` ast::Ty node,
-    // * or the `existential type` declaration
-    // The substitutions are for the generics of the function in question.
    // Opaque(DefId, Substs),
    // A type parameter; for example, `T` in `fn f<T>(x: T) {}
    // Param(ParamTy),
+    /// A type variable used during type checking. Not to be confused with a
-    // A placeholder type - universally quantified higher-ranked type.
+    /// type parameter.
-    // Placeholder(ty::PlaceholderType),
+    Infer(InferTy),
-    // A type variable used during type checking.
+    /// A placeholder for a type which could not be computed; this is propagated
-    // Infer(InferTy),
+    /// to avoid useless error messages. Doubles as a placeholder where type
-    /// A placeholder for a type which could not be computed; this is
+    /// variables are inserted before type checking, since we want to try to
-    /// propagated to avoid useless error messages.
+    /// infer a better type here anyway -- for the IDE use case, we want to try
+    /// to infer as much as possible even in the presence of type errors.
    Unknown,
 }
-type TyRef = Arc<Ty>;
+/// A function signature.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct FnSig {
    input: Vec<Ty>,
@@ -138,8 +243,8 @@ impl Ty {
                let inner_tys = inner
                    .iter()
                    .map(|tr| Ty::from_hir(db, module, tr))
-                    .collect::<Cancelable<_>>()?;
+                    .collect::<Cancelable<Vec<_>>>()?;
-                Ty::Tuple(inner_tys)
+                Ty::Tuple(inner_tys.into())
            }
            TypeRef::Path(path) => Ty::from_hir_path(db, module, path)?,
            TypeRef::RawPtr(inner, mutability) => {
@@ -155,7 +260,7 @@ impl Ty {
                let inner_ty = Ty::from_hir(db, module, inner)?;
                Ty::Ref(Arc::new(inner_ty), *mutability)
            }
-            TypeRef::Placeholder => Ty::Unknown, // TODO
+            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params) => {
                let mut inner_tys = params
                    .iter()
@@ -179,13 +284,12 @@ impl Ty {
        module: &Module,
        path: &Path,
    ) -> Cancelable<Self> {
-        if path.is_ident() {
+        if let Some(name) = path.as_ident() {
-            let name = &path.segments[0];
+            if let Some(int_ty) = primitive::IntTy::from_name(name) {
-            if let Some(int_ty) = primitive::IntTy::from_string(&name) {
                return Ok(Ty::Int(int_ty));
-            } else if let Some(uint_ty) = primitive::UintTy::from_string(&name) {
+            } else if let Some(uint_ty) = primitive::UintTy::from_name(name) {
                return Ok(Ty::Uint(uint_ty));
-            } else if let Some(float_ty) = primitive::FloatTy::from_string(&name) {
+            } else if let Some(float_ty) = primitive::FloatTy::from_name(name) {
                return Ok(Ty::Float(float_ty));
            }
        }
@@ -219,7 +323,41 @@ impl Ty {
    }
    pub fn unit() -> Self {
-        Ty::Tuple(Vec::new())
+        Ty::Tuple(Arc::new([]))
+    }
+    fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        f(self);
+        match self {
+            Ty::Slice(t) => Arc::make_mut(t).walk_mut(f),
+            Ty::RawPtr(t, _) => Arc::make_mut(t).walk_mut(f),
+            Ty::Ref(t, _) => Arc::make_mut(t).walk_mut(f),
+            Ty::Tuple(ts) => {
+                // Without an Arc::make_mut_slice, we can't avoid the clone here:
+                let mut v: Vec<_> = ts.iter().cloned().collect();
+                for t in &mut v {
+                    t.walk_mut(f);
+                }
+                *ts = v.into();
+            }
+            Ty::FnPtr(sig) => {
+                let sig_mut = Arc::make_mut(sig);
+                for input in &mut sig_mut.input {
+                    input.walk_mut(f);
+                }
+                sig_mut.output.walk_mut(f);
+            }
+            Ty::Adt { .. } => {} // need to walk type parameters later
+            _ => {}
+        }
+    }
+    fn fold(mut self, f: &mut impl FnMut(Ty) -> Ty) -> Ty {
+        self.walk_mut(&mut |ty_mut| {
+            let ty = mem::replace(ty_mut, Ty::Unknown);
+            *ty_mut = f(ty);
+        });
+        self
    }
 }
@@ -238,7 +376,7 @@ impl fmt::Display for Ty {
            Ty::Never => write!(f, "!"),
            Ty::Tuple(ts) => {
                write!(f, "(")?;
-                for t in ts {
+                for t in ts.iter() {
                    write!(f, "{},", t)?;
                }
                write!(f, ")")
@@ -252,11 +390,16 @@ impl fmt::Display for Ty {
            }
            Ty::Adt { name, .. } => write!(f, "{}", name),
            Ty::Unknown => write!(f, "[unknown]"),
+            Ty::Infer(..) => write!(f, "_"),
        }
    }
 }
-pub fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
+// Functions returning declared types for items
+/// Compute the declared type of a function. This should not need to look at the
+/// function body (but currently uses the function AST, so does anyway - TODO).
+fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
    let syntax = f.syntax(db);
    let module = f.module(db)?;
    let node = syntax.borrowed();
@@ -269,30 +412,30 @@ pub fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
                .collect()
        })
        .unwrap_or_else(|| Ok(Vec::new()))?;
-    let output = Ty::from_ast_opt(db, &module, node.ret_type().and_then(|rt| rt.type_ref()))?;
+    let output = if let Some(type_ref) = node.ret_type().and_then(|rt| rt.type_ref()) {
+        Ty::from_ast(db, &module, type_ref)?
+    } else {
+        Ty::unit()
+    };
    let sig = FnSig { input, output };
    Ok(Ty::FnPtr(Arc::new(sig)))
 }
-pub fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Cancelable<Ty> {
+fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Cancelable<Ty> {
    Ok(Ty::Adt {
        def_id: s.def_id(),
-        name: s
+        name: s.name(db)?.unwrap_or_else(Name::missing),
-            .name(db)?
-            .unwrap_or_else(|| SmolStr::new("[unnamed struct]")),
    })
 }
 pub fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Cancelable<Ty> {
    Ok(Ty::Adt {
        def_id: s.def_id(),
-        name: s
+        name: s.name(db)?.unwrap_or_else(Name::missing),
-            .name(db)?
-            .unwrap_or_else(|| SmolStr::new("[unnamed enum]")),
    })
 }
-pub fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
+pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
    let def = def_id.resolve(db)?;
    match def {
        Def::Module(..) => {
@@ -309,11 +452,7 @@ pub fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
    }
 }
-pub(super) fn type_for_field(
+pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Cancelable<Ty> {
-    db: &impl HirDatabase,
-    def_id: DefId,
-    field: SmolStr,
-) -> Cancelable<Ty> {
    let def = def_id.resolve(db)?;
    let variant_data = match def {
        Def::Struct(s) => {
@@ -336,23 +475,29 @@ pub(super) fn type_for_field(
    Ty::from_hir(db, &module, &type_ref)
 }
+/// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
    type_of: FxHashMap<LocalSyntaxPtr, Ty>,
 }
 impl InferenceResult {
+    /// Returns the type of the given syntax node, if it was inferred. Will
+    /// return `None` for syntax nodes not in the inferred function or not
+    /// pointing to an expression/pattern, `Some(Ty::Unknown)` for
+    /// expressions/patterns that could not be inferred.
    pub fn type_of_node(&self, node: SyntaxNodeRef) -> Option<Ty> {
        self.type_of.get(&LocalSyntaxPtr::new(node)).cloned()
    }
 }
+/// The inference context contains all information needed during type inference.
 #[derive(Clone, Debug)]
-pub struct InferenceContext<'a, D: HirDatabase> {
+struct InferenceContext<'a, D: HirDatabase> {
    db: &'a D,
    scopes: Arc<FnScopes>,
    module: Module,
-    // TODO unification tables...
+    var_unification_table: InPlaceUnificationTable<TypeVarId>,
    type_of: FxHashMap<LocalSyntaxPtr, Ty>,
 }
@@ -360,33 +505,116 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn new(db: &'a D, scopes: Arc<FnScopes>, module: Module) -> Self {
        InferenceContext {
            type_of: FxHashMap::default(),
+            var_unification_table: InPlaceUnificationTable::new(),
            db,
            scopes,
            module,
        }
    }
+    fn resolve_all(mut self) -> InferenceResult {
+        let mut types = mem::replace(&mut self.type_of, FxHashMap::default());
+        for ty in types.values_mut() {
+            let resolved = self.resolve_ty_completely(mem::replace(ty, Ty::Unknown));
+            *ty = resolved;
+        }
+        InferenceResult { type_of: types }
+    }
    fn write_ty(&mut self, node: SyntaxNodeRef, ty: Ty) {
        self.type_of.insert(LocalSyntaxPtr::new(node), ty);
    }
-    fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> Option<Ty> {
+    fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
-        if *ty1 == Ty::Unknown {
+        match (ty1, ty2) {
-            return Some(ty2.clone());
+            (Ty::Unknown, ..) => true,
-        }
+            (.., Ty::Unknown) => true,
-        if *ty2 == Ty::Unknown {
+            (Ty::Bool, _)
-            return Some(ty1.clone());
+            | (Ty::Str, _)
+            | (Ty::Never, _)
+            | (Ty::Char, _)
+            | (Ty::Int(..), Ty::Int(..))
+            | (Ty::Uint(..), Ty::Uint(..))
+            | (Ty::Float(..), Ty::Float(..)) => ty1 == ty2,
+            (
+                Ty::Adt {
+                    def_id: def_id1, ..
+                },
+                Ty::Adt {
+                    def_id: def_id2, ..
+                },
+            ) if def_id1 == def_id2 => true,
+            (Ty::Slice(t1), Ty::Slice(t2)) => self.unify(t1, t2),
+            (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => self.unify(t1, t2),
+            (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify(t1, t2),
+            (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true,
+            (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => ts1
+                .iter()
+                .zip(ts2.iter())
+                .all(|(t1, t2)| self.unify(t1, t2)),
+            (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) => {
+                self.var_unification_table.union(*tv1, *tv2);
+                true
+            }
+            (Ty::Infer(InferTy::TypeVar(tv)), other) | (other, Ty::Infer(InferTy::TypeVar(tv))) => {
+                self.var_unification_table
+                    .union_value(*tv, TypeVarValue::Known(other.clone()));
+                true
+            }
+            _ => false,
        }
-        if ty1 == ty2 {
+    }
-            return Some(ty1.clone());
+    fn new_type_var(&mut self) -> Ty {
+        Ty::Infer(InferTy::TypeVar(
+            self.var_unification_table.new_key(TypeVarValue::Unknown),
+        ))
+    }
+    /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
+    fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
+        match ty {
+            Ty::Unknown => self.new_type_var(),
+            _ => ty,
        }
-        // TODO implement actual unification
-        return None;
    }
-    fn unify_with_coercion(&mut self, ty1: &Ty, ty2: &Ty) -> Option<Ty> {
+    fn insert_type_vars(&mut self, ty: Ty) -> Ty {
-        // TODO implement coercion
+        ty.fold(&mut |ty| self.insert_type_vars_shallow(ty))
-        self.unify(ty1, ty2)
+    }
+    /// Resolves the type as far as currently possible, replacing type variables
+    /// by their known types. All types returned by the infer_* functions should
+    /// be resolved as far as possible, i.e. contain no type variables with
+    /// known type.
+    fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
+        ty.fold(&mut |ty| match ty {
+            Ty::Infer(InferTy::TypeVar(tv)) => {
+                if let Some(known_ty) = self.var_unification_table.probe_value(tv).known() {
+                    // known_ty may contain other variables that are known by now
+                    self.resolve_ty_as_possible(known_ty.clone())
+                } else {
+                    Ty::Infer(InferTy::TypeVar(tv))
+                }
+            }
+            _ => ty,
+        })
+    }
+    /// Resolves the type completely; type variables without known type are
+    /// replaced by Ty::Unknown.
+    fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
+        ty.fold(&mut |ty| match ty {
+            Ty::Infer(InferTy::TypeVar(tv)) => {
+                if let Some(known_ty) = self.var_unification_table.probe_value(tv).known() {
+                    // known_ty may contain other variables that are known by now
+                    self.resolve_ty_completely(known_ty.clone())
+                } else {
+                    Ty::Unknown
+                }
+            }
+            _ => ty,
+        })
    }
    fn infer_path_expr(&mut self, expr: ast::PathExpr) -> Cancelable<Option<Ty>> {
@@ -397,21 +625,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            let name = ctry!(ast_path.segment().and_then(|s| s.name_ref()));
            if let Some(scope_entry) = self.scopes.resolve_local_name(name) {
                let ty = ctry!(self.type_of.get(&scope_entry.ptr()));
-                return Ok(Some(ty.clone()));
+                let ty = self.resolve_ty_as_possible(ty.clone());
+                return Ok(Some(ty));
            };
        };
        // resolve in module
        let resolved = ctry!(self.module.resolve_path(self.db, &path)?.take_values());
        let ty = self.db.type_for_def(resolved)?;
-        // TODO we will need to add type variables for type parameters etc. here
+        let ty = self.insert_type_vars(ty);
        Ok(Some(ty))
    }
-    fn resolve_variant(
+    fn resolve_variant(&self, path: Option<ast::Path>) -> Cancelable<(Ty, Option<DefId>)> {
-        &self,
-        path: Option<ast::Path>,
-    ) -> Cancelable<(Ty, Option<Arc<VariantData>>)> {
        let path = if let Some(path) = path.and_then(Path::from_ast) {
            path
        } else {
@@ -424,102 +650,116 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        };
        Ok(match def_id.resolve(self.db)? {
            Def::Struct(s) => {
-                let struct_data = self.db.struct_data(def_id)?;
                let ty = type_for_struct(self.db, s)?;
-                (ty, Some(struct_data.variant_data().clone()))
+                (ty, Some(def_id))
            }
            _ => (Ty::Unknown, None),
        })
    }
-    fn infer_expr_opt(&mut self, expr: Option<ast::Expr>) -> Cancelable<Ty> {
+    fn infer_expr_opt(
+        &mut self,
+        expr: Option<ast::Expr>,
+        expected: &Expectation,
+    ) -> Cancelable<Ty> {
        if let Some(e) = expr {
-            self.infer_expr(e)
+            self.infer_expr(e, expected)
        } else {
            Ok(Ty::Unknown)
        }
    }
-    fn infer_expr(&mut self, expr: ast::Expr) -> Cancelable<Ty> {
+    fn infer_expr(&mut self, expr: ast::Expr, expected: &Expectation) -> Cancelable<Ty> {
        let ty = match expr {
            ast::Expr::IfExpr(e) => {
                if let Some(condition) = e.condition() {
-                    // TODO if no pat, this should be bool
+                    let expected = if condition.pat().is_none() {
-                    self.infer_expr_opt(condition.expr())?;
+                        Expectation::has_type(Ty::Bool)
+                    } else {
+                        Expectation::none()
+                    };
+                    self.infer_expr_opt(condition.expr(), &expected)?;
                    // TODO write type for pat
                };
-                let if_ty = self.infer_block_opt(e.then_branch())?;
+                let if_ty = self.infer_block_opt(e.then_branch(), expected)?;
-                let else_ty = self.infer_block_opt(e.else_branch())?;
+                if let Some(else_branch) = e.else_branch() {
-                if let Some(ty) = self.unify(&if_ty, &else_ty) {
+                    self.infer_block(else_branch, expected)?;
-                    ty
                } else {
-                    // TODO report diagnostic
+                    // no else branch -> unit
-                    Ty::Unknown
+                    self.unify(&expected.ty, &Ty::unit()); // actually coerce
                }
+                if_ty
            }
-            ast::Expr::BlockExpr(e) => self.infer_block_opt(e.block())?,
+            ast::Expr::BlockExpr(e) => self.infer_block_opt(e.block(), expected)?,
            ast::Expr::LoopExpr(e) => {
-                self.infer_block_opt(e.loop_body())?;
+                self.infer_block_opt(e.loop_body(), &Expectation::has_type(Ty::unit()))?;
                // TODO never, or the type of the break param
                Ty::Unknown
            }
            ast::Expr::WhileExpr(e) => {
                if let Some(condition) = e.condition() {
-                    // TODO if no pat, this should be bool
+                    let expected = if condition.pat().is_none() {
-                    self.infer_expr_opt(condition.expr())?;
+                        Expectation::has_type(Ty::Bool)
+                    } else {
+                        Expectation::none()
+                    };
+                    self.infer_expr_opt(condition.expr(), &expected)?;
                    // TODO write type for pat
                };
-                self.infer_block_opt(e.loop_body())?;
+                self.infer_block_opt(e.loop_body(), &Expectation::has_type(Ty::unit()))?;
                // TODO always unit?
-                Ty::Unknown
+                Ty::unit()
            }
            ast::Expr::ForExpr(e) => {
-                let _iterable_ty = self.infer_expr_opt(e.iterable());
+                let _iterable_ty = self.infer_expr_opt(e.iterable(), &Expectation::none());
                if let Some(_pat) = e.pat() {
                    // TODO write type for pat
                }
-                self.infer_block_opt(e.loop_body())?;
+                self.infer_block_opt(e.loop_body(), &Expectation::has_type(Ty::unit()))?;
                // TODO always unit?
-                Ty::Unknown
+                Ty::unit()
            }
            ast::Expr::LambdaExpr(e) => {
-                let _body_ty = self.infer_expr_opt(e.body())?;
+                let _body_ty = self.infer_expr_opt(e.body(), &Expectation::none())?;
                Ty::Unknown
            }
            ast::Expr::CallExpr(e) => {
-                let callee_ty = self.infer_expr_opt(e.expr())?;
+                let callee_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
-                if let Some(arg_list) = e.arg_list() {
+                let (arg_tys, ret_ty) = match &callee_ty {
-                    for arg in arg_list.args() {
+                    Ty::FnPtr(sig) => (&sig.input[..], sig.output.clone()),
-                        // TODO unify / expect argument type
-                        self.infer_expr(arg)?;
-                    }
-                }
-                match callee_ty {
-                    Ty::FnPtr(sig) => sig.output.clone(),
                    _ => {
                        // not callable
                        // TODO report an error?
-                        Ty::Unknown
+                        (&[][..], Ty::Unknown)
+                    }
+                };
+                if let Some(arg_list) = e.arg_list() {
+                    for (i, arg) in arg_list.args().enumerate() {
+                        self.infer_expr(
+                            arg,
+                            &Expectation::has_type(arg_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
+                        )?;
                    }
                }
+                ret_ty
            }
            ast::Expr::MethodCallExpr(e) => {
-                let _receiver_ty = self.infer_expr_opt(e.expr())?;
+                let _receiver_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                if let Some(arg_list) = e.arg_list() {
                    for arg in arg_list.args() {
                        // TODO unify / expect argument type
-                        self.infer_expr(arg)?;
+                        self.infer_expr(arg, &Expectation::none())?;
                    }
                }
                Ty::Unknown
            }
            ast::Expr::MatchExpr(e) => {
-                let _ty = self.infer_expr_opt(e.expr())?;
+                let _ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                if let Some(match_arm_list) = e.match_arm_list() {
                    for arm in match_arm_list.arms() {
                        // TODO type the bindings in pat
                        // TODO type the guard
-                        let _ty = self.infer_expr_opt(arm.expr())?;
+                        let _ty = self.infer_expr_opt(arm.expr(), &Expectation::none())?;
                    }
                    // TODO unify all the match arm types
                    Ty::Unknown
@@ -532,10 +772,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            ast::Expr::PathExpr(e) => self.infer_path_expr(e)?.unwrap_or(Ty::Unknown),
            ast::Expr::ContinueExpr(_e) => Ty::Never,
            ast::Expr::BreakExpr(_e) => Ty::Never,
-            ast::Expr::ParenExpr(e) => self.infer_expr_opt(e.expr())?,
+            ast::Expr::ParenExpr(e) => self.infer_expr_opt(e.expr(), expected)?,
            ast::Expr::Label(_e) => Ty::Unknown,
            ast::Expr::ReturnExpr(e) => {
-                self.infer_expr_opt(e.expr())?;
+                // TODO expect return type of function
+                self.infer_expr_opt(e.expr(), &Expectation::none())?;
                Ty::Never
            }
            ast::Expr::MatchArmList(_) | ast::Expr::MatchArm(_) | ast::Expr::MatchGuard(_) => {
@@ -543,11 +784,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                Ty::Unknown
            }
            ast::Expr::StructLit(e) => {
-                let (ty, _variant_data) = self.resolve_variant(e.path())?;
+                let (ty, def_id) = self.resolve_variant(e.path())?;
                if let Some(nfl) = e.named_field_list() {
                    for field in nfl.fields() {
-                        // TODO unify with / expect field type
+                        let field_ty = if let (Some(def_id), Some(nr)) = (def_id, field.name_ref())
-                        self.infer_expr_opt(field.expr())?;
+                        {
+                            self.db.type_for_field(def_id, nr.as_name())?
+                        } else {
+                            Ty::Unknown
+                        };
+                        self.infer_expr_opt(field.expr(), &Expectation::has_type(field_ty))?;
                    }
                }
                ty
@@ -558,40 +804,42 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            }
            ast::Expr::IndexExpr(_e) => Ty::Unknown,
            ast::Expr::FieldExpr(e) => {
-                let receiver_ty = self.infer_expr_opt(e.expr())?;
+                let receiver_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                if let Some(nr) = e.name_ref() {
-                    let text = nr.text();
+                    let ty = match receiver_ty {
-                    match receiver_ty {
                        Ty::Tuple(fields) => {
-                            let i = text.parse::<usize>().ok();
+                            let i = nr.text().parse::<usize>().ok();
                            i.and_then(|i| fields.get(i).cloned())
                                .unwrap_or(Ty::Unknown)
                        }
-                        Ty::Adt { def_id, .. } => self.db.type_for_field(def_id, text)?,
+                        Ty::Adt { def_id, .. } => self.db.type_for_field(def_id, nr.as_name())?,
                        _ => Ty::Unknown,
-                    }
+                    };
+                    self.insert_type_vars(ty)
                } else {
                    Ty::Unknown
                }
            }
            ast::Expr::TryExpr(e) => {
-                let _inner_ty = self.infer_expr_opt(e.expr())?;
+                let _inner_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                Ty::Unknown
            }
            ast::Expr::CastExpr(e) => {
-                let _inner_ty = self.infer_expr_opt(e.expr())?;
+                let _inner_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                let cast_ty = Ty::from_ast_opt(self.db, &self.module, e.type_ref())?;
+                let cast_ty = self.insert_type_vars(cast_ty);
                // TODO do the coercion...
                cast_ty
            }
            ast::Expr::RefExpr(e) => {
-                let inner_ty = self.infer_expr_opt(e.expr())?;
+                // TODO pass the expectation down
+                let inner_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                let m = Mutability::from_mutable(e.is_mut());
                // TODO reference coercions etc.
                Ty::Ref(Arc::new(inner_ty), m)
            }
            ast::Expr::PrefixExpr(e) => {
-                let inner_ty = self.infer_expr_opt(e.expr())?;
+                let inner_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
                match e.op() {
                    Some(PrefixOp::Deref) => {
                        match inner_ty {
@@ -609,28 +857,34 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            ast::Expr::BinExpr(_e) => Ty::Unknown,
            ast::Expr::Literal(_e) => Ty::Unknown,
        };
+        // use a new type variable if we got Ty::Unknown here
+        let ty = self.insert_type_vars_shallow(ty);
+        self.unify(&ty, &expected.ty);
        self.write_ty(expr.syntax(), ty.clone());
        Ok(ty)
    }
-    fn infer_block_opt(&mut self, node: Option<ast::Block>) -> Cancelable<Ty> {
+    fn infer_block_opt(
+        &mut self,
+        node: Option<ast::Block>,
+        expected: &Expectation,
+    ) -> Cancelable<Ty> {
        if let Some(b) = node {
-            self.infer_block(b)
+            self.infer_block(b, expected)
        } else {
            Ok(Ty::Unknown)
        }
    }
-    fn infer_block(&mut self, node: ast::Block) -> Cancelable<Ty> {
+    fn infer_block(&mut self, node: ast::Block, expected: &Expectation) -> Cancelable<Ty> {
        for stmt in node.statements() {
            match stmt {
                ast::Stmt::LetStmt(stmt) => {
                    let decl_ty = Ty::from_ast_opt(self.db, &self.module, stmt.type_ref())?;
+                    let decl_ty = self.insert_type_vars(decl_ty);
                    let ty = if let Some(expr) = stmt.initializer() {
-                        // TODO pass expectation
+                        let expr_ty = self.infer_expr(expr, &Expectation::has_type(decl_ty))?;
-                        let expr_ty = self.infer_expr(expr)?;
+                        expr_ty
-                        self.unify_with_coercion(&expr_ty, &decl_ty)
-                            .unwrap_or(decl_ty)
                    } else {
                        decl_ty
                    };
@@ -640,12 +894,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    };
                }
                ast::Stmt::ExprStmt(expr_stmt) => {
-                    self.infer_expr_opt(expr_stmt.expr())?;
+                    self.infer_expr_opt(expr_stmt.expr(), &Expectation::none())?;
                }
            }
        }
        let ty = if let Some(expr) = node.expr() {
-            self.infer_expr(expr)?
+            self.infer_expr(expr, expected)?
        } else {
            Ty::unit()
        };
@@ -654,7 +908,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
 }
-pub fn infer(db: &impl HirDatabase, function: Function) -> Cancelable<InferenceResult> {
+pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
+    let function = Function::new(def_id); // TODO: consts also need inference
    let scopes = function.scopes(db);
    let module = function.module(db)?;
    let mut ctx = InferenceContext::new(db, scopes, module);
@@ -671,25 +926,27 @@ pub fn infer(db: &impl HirDatabase, function: Function) -> Cancelable<InferenceR
            };
            if let Some(type_ref) = param.type_ref() {
                let ty = Ty::from_ast(db, &ctx.module, type_ref)?;
+                let ty = ctx.insert_type_vars(ty);
                ctx.type_of.insert(LocalSyntaxPtr::new(pat.syntax()), ty);
            } else {
                // TODO self param
+                let type_var = ctx.new_type_var();
                ctx.type_of
-                    .insert(LocalSyntaxPtr::new(pat.syntax()), Ty::Unknown);
+                    .insert(LocalSyntaxPtr::new(pat.syntax()), type_var);
            };
        }
    }
-    // TODO get Ty for node.ret_type() and pass that to infer_block as expectation
+    let ret_ty = if let Some(type_ref) = node.ret_type().and_then(|n| n.type_ref()) {
-    // (see Expectation in rustc_typeck)
+        let ty = Ty::from_ast(db, &ctx.module, type_ref)?;
+        ctx.insert_type_vars(ty)
+    } else {
+        Ty::unit()
+    };
    if let Some(block) = node.body() {
-        ctx.infer_block(block)?;
+        ctx.infer_block(block, &Expectation::has_type(ret_ty))?;
    }
-    // TODO 'resolve' the types: replace inference variables by their inferred results
+    Ok(Arc::new(ctx.resolve_all()))
-    Ok(InferenceResult {
-        type_of: ctx.type_of,
-    })
 }
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index ad79b17e4..498d42d52 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -1,5 +1,7 @@
 use std::fmt;
+use crate::{Name, KnownName};
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub enum IntTy {
    Isize,
@@ -34,14 +36,14 @@ impl IntTy {
        }
    }
-    pub fn from_string(s: &str) -> Option<IntTy> {
+    pub fn from_name(name: &Name) -> Option<IntTy> {
-        match s {
+        match name.as_known_name()? {
-            "isize" => Some(IntTy::Isize),
+            KnownName::Isize => Some(IntTy::Isize),
-            "i8" => Some(IntTy::I8),
+            KnownName::I8 => Some(IntTy::I8),
-            "i16" => Some(IntTy::I16),
+            KnownName::I16 => Some(IntTy::I16),
-            "i32" => Some(IntTy::I32),
+            KnownName::I32 => Some(IntTy::I32),
-            "i64" => Some(IntTy::I64),
+            KnownName::I64 => Some(IntTy::I64),
-            "i128" => Some(IntTy::I128),
+            KnownName::I128 => Some(IntTy::I128),
            _ => None,
        }
    }
@@ -69,14 +71,14 @@ impl UintTy {
        }
    }
-    pub fn from_string(s: &str) -> Option<UintTy> {
+    pub fn from_name(name: &Name) -> Option<UintTy> {
-        match s {
+        match name.as_known_name()? {
-            "usize" => Some(UintTy::Usize),
+            KnownName::Usize => Some(UintTy::Usize),
-            "u8" => Some(UintTy::U8),
+            KnownName::U8 => Some(UintTy::U8),
-            "u16" => Some(UintTy::U16),
+            KnownName::U16 => Some(UintTy::U16),
-            "u32" => Some(UintTy::U32),
+            KnownName::U32 => Some(UintTy::U32),
-            "u64" => Some(UintTy::U64),
+            KnownName::U64 => Some(UintTy::U64),
-            "u128" => Some(UintTy::U128),
+            KnownName::U128 => Some(UintTy::U128),
            _ => None,
        }
    }
@@ -120,10 +122,10 @@ impl FloatTy {
        }
    }
-    pub fn from_string(s: &str) -> Option<FloatTy> {
+    pub fn from_name(name: &Name) -> Option<FloatTy> {
-        match s {
+        match name.as_known_name()? {
-            "f32" => Some(FloatTy::F32),
+            KnownName::F32 => Some(FloatTy::F32),
-            "f64" => Some(FloatTy::F64),
+            KnownName::F64 => Some(FloatTy::F64),
            _ => None,
        }
    }
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index a76925b58..93bf431c4 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -113,6 +113,27 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
    );
 }
+#[test]
+fn infer_backwards() {
+    check_inference(
+        r#"
+fn takes_u32(x: u32) {}
+struct S { i32_field: i32 }
+fn test() -> &mut &f64 {
+    let a = unknown_function();
+    takes_u32(a);
+    let b = unknown_function();
+    S { i32_field: b };
+    let c = unknown_function();
+    &mut &c
+}
+"#,
+        "0006_backwards.txt",
+    );
+}
 fn infer(content: &str) -> String {
    let (db, _, file_id) = MockDatabase::with_single_file(content);
    let source_file = db.source_file(file_id);
diff --git a/crates/ra_hir/src/ty/tests/data/0002_let.txt b/crates/ra_hir/src/ty/tests/data/0002_let.txt
index 2d0d1f57b..916ca25a1 100644
--- a/crates/ra_hir/src/ty/tests/data/0002_let.txt
+++ b/crates/ra_hir/src/ty/tests/data/0002_let.txt
@@ -1,5 +1,5 @@
 [21; 22) 'a': [unknown]
-[52; 53) '1': [unknown]
+[52; 53) '1': usize
 [11; 71) '{     ...= b; }': ()
 [63; 64) 'c': usize
 [25; 31) '1isize': [unknown]
diff --git a/crates/ra_hir/src/ty/tests/data/0003_paths.txt b/crates/ra_hir/src/ty/tests/data/0003_paths.txt
index dcb5456ae..2a12d264f 100644
--- a/crates/ra_hir/src/ty/tests/data/0003_paths.txt
+++ b/crates/ra_hir/src/ty/tests/data/0003_paths.txt
@@ -1,7 +1,7 @@
-[15; 20) '{ 1 }': [unknown]
+[15; 20) '{ 1 }': u32
-[17; 18) '1': [unknown]
+[17; 18) '1': u32
-[50; 51) '1': [unknown]
+[50; 51) '1': u32
-[48; 53) '{ 1 }': [unknown]
+[48; 53) '{ 1 }': u32
 [82; 88) 'b::c()': u32
 [67; 91) '{     ...c(); }': ()
 [73; 74) 'a': fn() -> u32
diff --git a/crates/ra_hir/src/ty/tests/data/0004_struct.txt b/crates/ra_hir/src/ty/tests/data/0004_struct.txt
index cc8f3665b..b4af18b87 100644
--- a/crates/ra_hir/src/ty/tests/data/0004_struct.txt
+++ b/crates/ra_hir/src/ty/tests/data/0004_struct.txt
@@ -1,5 +1,5 @@
 [86; 90) 'C(1)': [unknown]
-[121; 122) 'B': [unknown]
+[121; 122) 'B': B
 [86; 87) 'C': [unknown]
 [129; 130) '1': [unknown]
 [107; 108) 'a': A
@@ -13,4 +13,4 @@
 [96; 97) 'B': [unknown]
 [88; 89) '1': [unknown]
 [82; 83) 'c': [unknown]
-[127; 131) 'C(1)': [unknown]
+[127; 131) 'C(1)': C
diff --git a/crates/ra_hir/src/ty/tests/data/0006_backwards.txt b/crates/ra_hir/src/ty/tests/data/0006_backwards.txt
new file mode 100644
index 000000000..120069401
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/0006_backwards.txt
@@ -0,0 +1,20 @@
+[22; 24) '{}': ()
+[14; 15) 'x': u32
+[142; 158) 'unknow...nction': [unknown]
+[126; 127) 'a': u32
+[198; 216) 'unknow...tion()': f64
+[228; 229) 'c': f64
+[198; 214) 'unknow...nction': [unknown]
+[166; 184) 'S { i3...d: b }': S
+[222; 229) '&mut &c': &mut &f64
+[194; 195) 'c': f64
+[92; 110) 'unknow...tion()': u32
+[142; 160) 'unknow...tion()': i32
+[92; 108) 'unknow...nction': [unknown]
+[116; 128) 'takes_u32(a)': ()
+[78; 231) '{     ...t &c }': &mut &f64
+[227; 229) '&c': &f64
+[88; 89) 'a': u32
+[181; 182) 'b': i32
+[116; 125) 'takes_u32': fn(u32,) -> ()
+[138; 139) 'b': i32
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index 3c8c240cd..646df2497 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -11,13 +11,13 @@ relative-path = "0.4.0"
 failure = "0.1.2"
 failure_derive = "0.1.2"
 serde_json = "1.0.24"
-serde = "1.0.71"
+serde = "1.0.83"
 drop_bomb = "0.1.0"
 crossbeam-channel = "0.2.4"
 flexi_logger = "0.10.0"
 log = "0.4.3"
 url_serde = "0.2.0"
-languageserver-types = "0.53.0"
+languageserver-types = "0.53.1"
 walkdir = "2.2.7"
 im = "12.0.0"
 cargo_metadata = "0.6.0"
@@ -37,3 +37,4 @@ ra_vfs = { path = "../ra_vfs" }
 [dev-dependencies]
 tempdir = "0.3.7"
 test_utils = { path = "../test_utils" }
+tools = { path = "../tools" }
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index 5f7038f63..8d508a3ba 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -33,7 +33,7 @@ pub fn server_capabilities() -> ServerCapabilities {
        workspace_symbol_provider: Some(true),
        code_action_provider: Some(CodeActionProviderCapability::Simple(true)),
        code_lens_provider: None,
-        document_formatting_provider: None,
+        document_formatting_provider: Some(true),
        document_range_formatting_provider: None,
        document_on_type_formatting_provider: Some(DocumentOnTypeFormattingOptions {
            first_trigger_character: "=".to_string(),
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index d3670104e..0d6e62727 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -2,7 +2,7 @@ use languageserver_types::{
    self, Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, InsertTextFormat,
 };
-use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition, CompletionItem, CompletionItemKind, InsertText};
+use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition,FileRange,  CompletionItem, CompletionItemKind, InsertText};
 use ra_editor::{LineCol, LineIndex, translate_offset_with_edit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
@@ -57,6 +57,7 @@ impl Conv for CompletionItemKind {
            CompletionItemKind::Function => Function,
            CompletionItemKind::Struct => Struct,
            CompletionItemKind::Enum => Enum,
+            CompletionItemKind::EnumVariant => EnumMember,
            CompletionItemKind::Binding => Variable,
            CompletionItemKind::Field => Field,
        }
@@ -218,6 +219,17 @@ impl<'a> TryConvWith for &'a TextDocumentPositionParams {
    }
 }
+impl<'a> TryConvWith for (&'a TextDocumentIdentifier, Range) {
+    type Ctx = ServerWorld;
+    type Output = FileRange;
+    fn try_conv_with(self, world: &ServerWorld) -> Result<FileRange> {
+        let file_id = self.0.try_conv_with(world)?;
+        let line_index = world.analysis().file_line_index(file_id);
+        let range = self.1.conv_with(&line_index);
+        Ok(FileRange { file_id, range })
+    }
+}
 impl<T: TryConvWith> TryConvWith for Vec<T> {
    type Ctx = <T as TryConvWith>::Ctx;
    type Output = Vec<<T as TryConvWith>::Output>;
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 1edb9fae4..97c1be778 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -295,6 +295,7 @@ fn on_request(
        .on::<req::PrepareRenameRequest>(handlers::handle_prepare_rename)?
        .on::<req::Rename>(handlers::handle_rename)?
        .on::<req::References>(handlers::handle_references)?
+        .on::<req::Formatting>(handlers::handle_formatting)?
        .finish();
    match req {
        Ok(id) => {
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 0e9a66a8a..a2c12a4c1 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -6,13 +6,16 @@ use languageserver_types::{
    DiagnosticSeverity, DocumentSymbol, Documentation, FoldingRange, FoldingRangeKind,
    FoldingRangeParams, Location, MarkupContent, MarkupKind, MarkedString, Position,
    PrepareRenameResponse, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit,
+    Range,
    WorkspaceEdit, ParameterInformation, ParameterLabel, SignatureInformation, Hover, HoverContents,
+    DocumentFormattingParams,
 };
-use ra_analysis::{FileId, FoldKind, Query, RunnableKind, FilePosition, Severity};
+use ra_analysis::{FileId, FoldKind, Query, RunnableKind, FileRange, FilePosition, Severity};
 use ra_syntax::{TextUnit, text_utils::intersect};
 use ra_text_edit::text_utils::contains_offset_nonstrict;
 use rustc_hash::FxHashMap;
 use serde_json::to_value;
+use std::io::Write;
 use crate::{
    conv::{to_location, Conv, ConvWith, MapConvWith, TryConvWith},
@@ -33,13 +36,13 @@ pub fn handle_extend_selection(
    params: req::ExtendSelectionParams,
 ) -> Result<req::ExtendSelectionResult> {
    let file_id = params.text_document.try_conv_with(&world)?;
-    let file = world.analysis().file_syntax(file_id);
    let line_index = world.analysis().file_line_index(file_id);
    let selections = params
        .selections
        .into_iter()
        .map_conv_with(&line_index)
-        .map(|r| world.analysis().extend_selection(&file, r))
+        .map(|range| FileRange { file_id, range })
+        .map(|frange| world.analysis().extend_selection(frange))
        .map_conv_with(&line_index)
        .collect();
    Ok(req::ExtendSelectionResult { selections })
@@ -71,13 +74,8 @@ pub fn handle_join_lines(
    world: ServerWorld,
    params: req::JoinLinesParams,
 ) -> Result<req::SourceChange> {
-    let file_id = params.text_document.try_conv_with(&world)?;
+    let frange = (&params.text_document, params.range).try_conv_with(&world)?;
-    let line_index = world.analysis().file_line_index(file_id);
+    world.analysis().join_lines(frange).try_conv_with(&world)
-    let range = params.range.conv_with(&line_index);
-    world
-        .analysis()
-        .join_lines(file_id, range)
-        .try_conv_with(&world)
 }
 pub fn handle_on_enter(
@@ -606,6 +604,40 @@ pub fn handle_references(
    ))
 }
+pub fn handle_formatting(
+    world: ServerWorld,
+    params: DocumentFormattingParams,
+) -> Result<Option<Vec<TextEdit>>> {
+    let file_id = params.text_document.try_conv_with(&world)?;
+    let file = world.analysis().file_text(file_id);
+    let file_line_index = world.analysis().file_line_index(file_id);
+    let end_position = TextUnit::of_str(&file).conv_with(&file_line_index);
+    use std::process;
+    let mut rustfmt = process::Command::new("rustfmt")
+        .stdin(process::Stdio::piped())
+        .stdout(process::Stdio::piped())
+        .spawn()?;
+    rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
+    let output = rustfmt.wait_with_output()?;
+    let captured_stdout = String::from_utf8(output.stdout)?;
+    if !output.status.success() {
+        failure::bail!(
+            "rustfmt exited with error code {}: {}.",
+            output.status,
+            captured_stdout,
+        );
+    }
+    Ok(Some(vec![TextEdit {
+        range: Range::new(Position::new(0, 0), end_position),
+        new_text: captured_stdout,
+    }]))
+}
 pub fn handle_code_action(
    world: ServerWorld,
    params: req::CodeActionParams,
@@ -614,7 +646,10 @@ pub fn handle_code_action(
    let line_index = world.analysis().file_line_index(file_id);
    let range = params.range.conv_with(&line_index);
-    let assists = world.analysis().assists(file_id, range)?.into_iter();
+    let assists = world
+        .analysis()
+        .assists(FileRange { file_id, range })?
+        .into_iter();
    let fixes = world
        .analysis()
        .diagnostics(file_id)?
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index 1f5cc5e8b..b0e1e65b6 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -1,8 +1,8 @@
 mod support;
 use serde_json::json;
-use ra_lsp_server::req::{Runnables, RunnablesParams, CodeActionRequest, CodeActionParams};
+use ra_lsp_server::req::{Runnables, RunnablesParams, CodeActionRequest, CodeActionParams, Formatting};
-use languageserver_types::{Position, Range, CodeActionContext};
+use languageserver_types::{Position, Range, CodeActionContext, DocumentFormattingParams, FormattingOptions};
 use crate::support::project;
@@ -118,6 +118,60 @@ fn test_eggs() {}
    );
 }
+use std::collections::HashMap;
+#[test]
+fn test_format_document() {
+    tools::install_rustfmt().unwrap();
+    let server = project(
+        r#"
+[package]
+name = "foo"
+version = "0.0.0"
+//- src/lib.rs
+mod bar;
+fn main() {
+}
+pub use std::collections::HashMap;
+"#,
+    );
+    server.wait_for_feedback("workspace loaded");
+    server.request::<Formatting>(
+        DocumentFormattingParams {
+            text_document: server.doc_id("src/lib.rs"),
+            options: FormattingOptions {
+                tab_size: 4,
+                insert_spaces: false,
+                properties: HashMap::new(),
+            },
+        },
+        json!([
+            {
+                "newText": r#"mod bar;
+fn main() {}
+pub use std::collections::HashMap;
+"#,
+                "range": {
+                    "end": {
+                        "character": 0,
+                        "line": 6
+                    },
+                    "start": {
+                        "character": 0,
+                        "line": 0
+                    }
+                }
+            }
+        ]),
+    );
+}
 #[test]
 fn test_missing_module_code_action() {
    let server = project(
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 8c9a7e238..fd6966d4a 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -8,11 +8,11 @@ description = "Comment and whitespace preserving parser for the Rust langauge"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 [dependencies]
-arrayvec = "0.4.7"
+arrayvec = "0.4.10"
 unicode-xid = "0.1.0"
-itertools = "0.7.8"
+itertools = "0.8.0"
 drop_bomb = "0.1.4"
-parking_lot = "0.6.0"
+parking_lot = "0.7.0"
 rowan = "0.1.2"
 text_unit = "0.1.5"
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_syntax/fuzz/Cargo.lock b/crates/ra_syntax/fuzz/Cargo.lock
new file mode 100644
index 000000000..e68fe7f61
--- /dev/null
+++ b/crates/ra_syntax/fuzz/Cargo.lock
@@ -0,0 +1,530 @@
+[[package]]
+name = "arbitrary"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "arrayvec"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "bit-set"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "bit-vec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "bitflags"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "byteorder"
+version = "1.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "cc"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "cfg-if"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "drop_bomb"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "either"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "fnv"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "itertools"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "lazy_static"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "libc"
+version = "0.2.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "libfuzzer-sys"
+version = "0.1.0"
+source = "git+https://github.com/rust-fuzz/libfuzzer-sys.git#4a413199b5cb1bbed6a1d157b2342b925f8464ac"
+dependencies = [
+ "arbitrary 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "lock_api"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "nodrop"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "num-traits"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "owning_ref"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "parking_lot"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "parking_lot"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "parking_lot_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "parking_lot_core"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "proptest"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "quick-error"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "ra_syntax"
+version = "0.1.0"
+dependencies = [
+ "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "drop_bomb 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_text_edit 0.1.0",
+ "rowan 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "ra_syntax-fuzz"
+version = "0.0.1"
+dependencies = [
+ "libfuzzer-sys 0.1.0 (git+https://github.com/rust-fuzz/libfuzzer-sys.git)",
+ "ra_syntax 0.1.0",
+]
+[[package]]
+name = "ra_text_edit"
+version = "0.1.0"
+dependencies = [
+ "proptest 0.8.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_chacha"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_core"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "rand_hc"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_isaac"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_pcg"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rand_xorshift"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "redox_syscall"
+version = "0.1.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "regex-syntax"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "remove_dir_all"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rowan"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "rusty-fork"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "wait-timeout 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "scopeguard"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "smallvec"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "smol_str"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "stable_deref_trait"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "tempfile"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)",
+ "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "text_unit"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "ucd-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "unicode-xid"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "unreachable"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "wait-timeout"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "winapi"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[metadata]
+"checksum arbitrary 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6c7d1523aa3a127adf8b27af2404c03c12825b4c4d0698f01648d63fa9df62ee"
+"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
+"checksum bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6f1efcc46c18245a69c38fcc5cc650f16d3a59d034f3106e9ed63748f695730a"
+"checksum bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4440d5cb623bb7390ae27fec0bb6c61111969860f8e3ae198bfa0663645e67cf"
+"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
+"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"
+"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
+"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
+"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+"checksum drop_bomb 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "69b26e475fd29098530e709294e94e661974c851aed42512793f120fed4e199f"
+"checksum either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3be565ca5c557d7f59e7cfcf1844f9e3033650c929c6566f511e8005f205c1d0"
+"checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
+"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+"checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358"
+"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
+"checksum libc 0.2.45 (registry+https://github.com/rust-lang/crates.io-index)" = "2d2857ec59fadc0773853c664d2d18e7198e83883e7060b63c924cb077bd5c74"
+"checksum libfuzzer-sys 0.1.0 (git+https://github.com/rust-fuzz/libfuzzer-sys.git)" = "<none>"
+"checksum lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "62ebf1391f6acad60e5c8b43706dde4582df75c06698ab44511d15016bc2442c"
+"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
+"checksum num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0b3a5d7cc97d6d30d8b9bc8fa19bf45349ffe46241e8816f50f62f6d6aaabee1"
+"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
+"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
+"checksum parking_lot 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9723236a9525c757d9725b993511e3fc941e33f27751942232f0058298297edf"
+"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"
+"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
+"checksum proptest 0.8.7 (registry+https://github.com/rust-lang/crates.io-index)" = "926d0604475349f463fe44130aae73f2294b5309ab2ca0310b998bd334ef191f"
+"checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
+"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
+"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
+"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"
+"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
+"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"
+"checksum rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4"
+"checksum rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08"
+"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
+"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
+"checksum redox_syscall 0.1.49 (registry+https://github.com/rust-lang/crates.io-index)" = "f22c50afdcf3f0a31ebb6b47697f6a7c5e5a24967e842858118bce0615f0afad"
+"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
+"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
+"checksum rowan 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a9ccca91953e9c549cac18e8f41daa5d49dad1c9a4c9bb977ac42718bb34e1bf"
+"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+"checksum rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9591f190d2852720b679c21f66ad929f9f1d7bb09d1193c26167586029d8489c"
+"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
+"checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+"checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
+"checksum smol_str 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "486a74e9b9fc53373808f7a17e10fc728adcb1fbe272292271d8bea61175e181"
+"checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
+"checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
+"checksum text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8009d7bdbd896a7e09b595f8f9325a19047fc708653e60d0895202b82135048f"
+"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"
+"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
+"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+"checksum wait-timeout 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "b9f3bf741a801531993db6478b95682117471f76916f5e690dd8d45395b09349"
+"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
+"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index c22e026cf..c5ac90a62 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1838,6 +1838,51 @@ impl<R: TreeRoot<RaTypes>> LoopExprNode<R> {
 impl<'a> ast::LoopBodyOwner<'a> for LoopExpr<'a> {}
 impl<'a> LoopExpr<'a> {}
+// MacroCall
+#[derive(Debug, Clone, Copy,)]
+pub struct MacroCallNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type MacroCall<'a> = MacroCallNode<RefRoot<'a>>;
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MacroCallNode<R1>> for MacroCallNode<R2> {
+    fn eq(&self, other: &MacroCallNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for MacroCallNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for MacroCallNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+impl<'a> AstNode<'a> for MacroCall<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            MACRO_CALL => Some(MacroCall { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+impl<R: TreeRoot<RaTypes>> MacroCallNode<R> {
+    pub fn borrowed(&self) -> MacroCall {
+        MacroCallNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> MacroCallNode {
+        MacroCallNode { syntax: self.syntax.owned() }
+    }
+}
+impl<'a> MacroCall<'a> {
+    pub fn token_tree(self) -> Option<TokenTree<'a>> {
+        super::child_opt(self)
+    }
+    pub fn path(self) -> Option<Path<'a>> {
+        super::child_opt(self)
+    }
+}
 // MatchArm
 #[derive(Debug, Clone, Copy,)]
 pub struct MatchArmNode<R: TreeRoot<RaTypes> = OwnedRoot> {
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 4bcff4e14..aab4839a9 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -484,6 +484,7 @@ Grammar(
        "Name": (),
        "NameRef": (),
+        "MacroCall": ( options: [ "TokenTree", "Path" ] ),
        "Attr": ( options: [ ["value", "TokenTree"] ] ),
        "TokenTree": (),
        "TypeParamList": (
diff --git a/crates/ra_syntax/src/string_lexing/parser.rs b/crates/ra_syntax/src/string_lexing/parser.rs
index 14c6015c2..e835382fc 100644
--- a/crates/ra_syntax/src/string_lexing/parser.rs
+++ b/crates/ra_syntax/src/string_lexing/parser.rs
@@ -82,7 +82,7 @@ impl<'a> Parser<'a> {
    fn parse_escape(&mut self, start: TextUnit) -> StringComponent {
        if self.peek().is_none() {
-            return StringComponent::new(TextRange::from_to(start, start), AsciiEscape);
+            return StringComponent::new(TextRange::from_to(start, self.get_pos()), AsciiEscape);
        }
        let next = self.advance();
diff --git a/crates/ra_syntax/src/validation/char.rs b/crates/ra_syntax/src/validation/char.rs
index 19cd3830f..10d3d1dec 100644
--- a/crates/ra_syntax/src/validation/char.rs
+++ b/crates/ra_syntax/src/validation/char.rs
@@ -70,7 +70,7 @@ pub(super) fn validate_char_component(
 fn validate_ascii_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
    if text.len() == 1 {
-        // Escape sequence consists only of leading `\`
+        // Escape sequence consists only of leading `\` (only occurs at EOF, otherwise e.g. '\' is treated as an unclosed char containing a single quote `'`)
        errors.push(SyntaxError::new(EmptyAsciiEscape, range));
    } else {
        let escape_code = text.chars().skip(1).next().unwrap();
diff --git a/crates/ra_syntax/tests/data/parser/fuzz-failures/0002.rs b/crates/ra_syntax/tests/data/parser/fuzz-failures/0002.rs
new file mode 100644
index 000000000..f35dc7289
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/fuzz-failures/0002.rs
@@ -0,0 +1 @@
+!('\
+\ No newline at end of file
diff --git a/crates/ra_vfs/src/io.rs b/crates/ra_vfs/src/io.rs
index be400bae9..4cfdb83da 100644
--- a/crates/ra_vfs/src/io.rs
+++ b/crates/ra_vfs/src/io.rs
@@ -8,7 +8,7 @@ use walkdir::{DirEntry, WalkDir};
 use thread_worker::{WorkerHandle};
 use relative_path::RelativePathBuf;
-use crate::VfsRoot;
+use crate::{VfsRoot, has_rs_extension};
 pub(crate) struct Task {
    pub(crate) root: VfsRoot,
@@ -59,7 +59,7 @@ fn load_root(root: &Path, filter: &dyn Fn(&DirEntry) -> bool) -> Vec<(RelativePa
            continue;
        }
        let path = entry.path();
-        if path.extension().and_then(|os| os.to_str()) != Some("rs") {
+        if !has_rs_extension(path) {
            continue;
        }
        let text = match fs::read_to_string(path) {
diff --git a/crates/ra_vfs/src/lib.rs b/crates/ra_vfs/src/lib.rs
index 4de07b093..90d5e21f4 100644
--- a/crates/ra_vfs/src/lib.rs
+++ b/crates/ra_vfs/src/lib.rs
@@ -2,11 +2,13 @@
 //!
 //! When doing analysis, we don't want to do any IO, we want to keep all source
 //! code in memory. However, the actual source code is stored on disk, so you
-//! component which does this.
 //! need to get it into the memory in the first place somehow. VFS is the
+//! component which does this.
 //!
-//! It also is responsible for watching the disk for changes, and for merging
+//! It is also responsible for watching the disk for changes, and for merging
 //! editor state (modified, unsaved files) with disk state.
+//! TODO: Some LSP clients support watching the disk, so this crate should
+//! to support custom watcher events (related to https://github.com/rust-analyzer/rust-analyzer/issues/131)
 //!
 //! VFS is based on a concept of roots: a set of directories on the file system
 //! whihc are watched for changes. Typically, there will be a root for each
@@ -29,7 +31,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use relative_path::RelativePathBuf;
 use crossbeam_channel::Receiver;
 use walkdir::DirEntry;
-use thread_worker::{WorkerHandle};
+use thread_worker::WorkerHandle;
 use crate::{
    arena::{ArenaId, Arena},
@@ -57,12 +59,8 @@ impl RootFilter {
        if !(self.file_filter)(path) {
            return None;
        }
-        if !(path.starts_with(&self.root)) {
+        let path = path.strip_prefix(&self.root).ok()?;
-            return None;
+        RelativePathBuf::from_path(path).ok()
-        }
-        let path = path.strip_prefix(&self.root).unwrap();
-        let path = RelativePathBuf::from_path(path).unwrap();
-        Some(path)
    }
 }
diff --git a/crates/test_utils/Cargo.toml b/crates/test_utils/Cargo.toml
index 8c8fcd7ae..02727993e 100644
--- a/crates/test_utils/Cargo.toml
+++ b/crates/test_utils/Cargo.toml
@@ -6,6 +6,6 @@ authors = ["Aleksey Kladov <[email protected]>"]
 [dependencies]
 difference = "2.0.0"
-itertools = "0.7.8"
+itertools = "0.8.0"
 text_unit = "0.1.2"
 serde_json = "1.0.24"
diff --git a/crates/tools/Cargo.toml b/crates/tools/Cargo.toml
index 41b19c5c6..4795b1387 100644
--- a/crates/tools/Cargo.toml
+++ b/crates/tools/Cargo.toml
@@ -8,6 +8,6 @@ publish = false
 [dependencies]
 teraron = "0.0.1"
 walkdir = "2.1.3"
-itertools = "0.7.8"
+itertools = "0.8.0"
 clap = "2.32.0"
 failure = "0.1.1"
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 6f96b8120..e5b32c25c 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -117,7 +117,7 @@ pub fn run_rustfmt(mode: Mode) -> Result<()> {
    Ok(())
 }
-fn install_rustfmt() -> Result<()> {
+pub fn install_rustfmt() -> Result<()> {
    run(&format!("rustup install {}", TOOLCHAIN), ".")?;
    run(
        &format!("rustup component add rustfmt --toolchain {}", TOOLCHAIN),