43 files changed, 663 insertions, 285 deletions

diff --git a/.cargo/config b/.cargo/config
index 3fba0f71d..b12f407e6 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -5,6 +5,8 @@ gen-syntax   = "run --package tools --bin tools -- gen-syntax"
 gen-tests    = "run --package tools --bin tools -- gen-tests"
 # Installs ra_lsp_server
 install-lsp = "install --path crates/ra_lsp_server --force"
+# Installs ra_lsp_server with the jemalloc feature
+jinstall-lsp = "install --path crates/ra_lsp_server --force --features jemalloc"
 # Installs the visual studio code extension
 install-code = "run --package tools --bin tools -- install-code"
 # Formats the full repository or installs the git hook to do it automatically.
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index cb8f01f78..8602de56d 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -178,7 +178,7 @@ VS Code plugin
 
 To try out VS Code extensions, run `cargo install-code`.  This installs both the
 `ra_lsp_server` binary and the VS Code extension. To install only the binary, use
-`cargo install --path crates/ra_lsp_server --force`
+`cargo install-lsp` (shorthand for `cargo install --path crates/ra_lsp_server --force`)
 
 To see logs from the language server, set `RUST_LOG=info` env variable. To see
 all communication between the server and the client, use
@@ -186,12 +186,12 @@ all communication between the server and the client, use
 
 There's `rust-analyzer: status` command which prints common high-level debug
 info. In particular, it prints info about memory usage of various data
-structures, and, if compiled with jemalloc support (`cargo install --features
-jemalloc`), the summary statistic about the heap.
+structures, and, if compiled with jemalloc support (`cargo jinstall-lsp` or 
+`cargo install --path crates/ra_lsp_server --force --features jemalloc`), includes
+ statistic about the heap.
 
 To run tests, just `cargo test`.
 
 To work on the VS Code extension, launch code inside `editors/code` and use `F5` to
 launch/debug. To automatically apply formatter and linter suggestions, use `npm
 run fix`.
-
diff --git a/README.md b/README.md
index ad600d162..cffc00953 100644
--- a/README.md
+++ b/README.md
@@ -120,7 +120,7 @@ and trait selection) to the existing rustc.
 - [ ] [textDocument/declaration](https://microsoft.github.io/language-server-protocol/specification#textDocument_declaration)
 - [x] [textDocument/definition](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition)
 - [ ] [textDocument/typeDefinition](https://microsoft.github.io/language-server-protocol/specification#textDocument_typeDefinition)
-- [ ] [textDocument/implementation](https://microsoft.github.io/language-server-protocol/specification#textDocument_implementation)
+- [x] [textDocument/implementation](https://microsoft.github.io/language-server-protocol/specification#textDocument_implementation)
 - [x] [textDocument/references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
 - [x] [textDocument/documentHighlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
 - [x] [textDocument/documentSymbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol)
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index e4008058c..9405aa8ad 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -10,12 +10,13 @@ use crate::{
     nameres::{ModuleScope, lower::ImportId},
     db::HirDatabase,
     expr::BodySyntaxMapping,
-    ty::InferenceResult,
+    ty::{InferenceResult},
     adt::{EnumVariantId, StructFieldId, VariantDef},
     generics::GenericParams,
     docs::{Documentation, Docs, docs_from_ast},
     module_tree::ModuleId,
     ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
+    impl_block::ImplId,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -51,7 +52,7 @@ pub enum Def {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
-    pub(crate) krate: CrateId,
+    pub(crate) krate: Crate,
     pub(crate) module_id: ModuleId,
 }
 
@@ -126,9 +127,14 @@ impl Module {
         self.import_source_impl(db, import)
     }
 
+    /// Returns the syntax of the impl block in this module
+    pub fn impl_source(&self, db: &impl HirDatabase, impl_id: ImplId) -> TreeArc<ast::ImplBlock> {
+        self.impl_source_impl(db, impl_id)
+    }
+
     /// Returns the crate this module is part of.
-    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
-        self.krate_impl(db)
+    pub fn krate(&self, _db: &impl HirDatabase) -> Option<Crate> {
+        Some(self.krate)
     }
 
     /// Topmost parent of this module. Every module has a `crate_root`, but some
@@ -272,6 +278,10 @@ impl Struct {
     pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
+
+    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
+        db.type_for_def((*self).into())
+    }
 }
 
 impl Docs for Struct {
@@ -317,6 +327,10 @@ impl Enum {
     pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
         db.generic_params((*self).into())
     }
+
+    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
+        db.type_for_def((*self).into())
+    }
 }
 
 impl Docs for Enum {
@@ -382,7 +396,7 @@ pub struct Function {
     pub(crate) id: FunctionId,
 }
 
-pub use crate::code_model_impl::function::ScopeEntryWithSyntax;
+pub use crate::expr::ScopeEntryWithSyntax;
 
 /// The declared signature of a function.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -433,7 +447,7 @@ impl Function {
     }
 
     pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
-        let scopes = db.fn_scopes(*self);
+        let scopes = db.expr_scopes(*self);
         let syntax_mapping = db.body_syntax_mapping(*self);
         ScopesWithSyntaxMapping {
             scopes,
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index e0dd4d629..422643996 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -1,5 +1,3 @@
-mod scope;
-
 use std::sync::Arc;
 
 use ra_syntax::ast::{self, NameOwner};
@@ -11,8 +9,6 @@ use crate::{
     impl_block::ImplBlock,
 };
 
-pub use self::scope::{FnScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
-
 impl Function {
     pub(crate) fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
         db.body_hir(*self)
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index cdd30b402..86f29d959 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -1,31 +1,28 @@
-use ra_db::CrateId;
-
 use crate::{
     Crate, CrateDependency, AsName, Module,
     db::HirDatabase,
 };
 
 impl Crate {
-    pub(crate) fn new(crate_id: CrateId) -> Crate {
-        Crate { crate_id }
-    }
     pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
         let crate_graph = db.crate_graph();
         crate_graph
             .dependencies(self.crate_id)
             .map(|dep| {
-                let krate = Crate::new(dep.crate_id());
+                let krate = Crate {
+                    crate_id: dep.crate_id(),
+                };
                 let name = dep.as_name();
                 CrateDependency { krate, name }
             })
             .collect()
     }
     pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Option<Module> {
-        let module_tree = db.module_tree(self.crate_id);
+        let module_tree = db.module_tree(*self);
         let module_id = module_tree.modules().next()?;
 
         let module = Module {
-            krate: self.crate_id,
+            krate: *self,
             module_id,
         };
         Some(module)
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 418d59c91..4a3901b8b 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -3,8 +3,9 @@ use ra_syntax::{ast, SyntaxNode, TreeArc};
 
 use crate::{
     Module, ModuleSource, Problem,
-    Crate, Name,
+    Name,
     module_tree::ModuleId,
+    impl_block::ImplId,
     nameres::{lower::ImportId},
     db::HirDatabase,
 };
@@ -51,13 +52,19 @@ impl Module {
         db: &impl HirDatabase,
         import: ImportId,
     ) -> TreeArc<ast::PathSegment> {
-        let source_map = db.lower_module_source_map(self.clone());
+        let source_map = db.lower_module_source_map(*self);
         let (_, source) = self.definition_source(db);
         source_map.get(&source, import)
     }
 
-    pub(crate) fn krate_impl(&self, _db: &impl HirDatabase) -> Option<Crate> {
-        Some(Crate::new(self.krate))
+    pub(crate) fn impl_source_impl(
+        &self,
+        db: &impl HirDatabase,
+        impl_id: ImplId,
+    ) -> TreeArc<ast::ImplBlock> {
+        let source_map = db.impls_in_module_source_map(*self);
+        let (_, source) = self.definition_source(db);
+        source_map.get(&source, impl_id)
     }
 
     pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Module {
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 3f76b769d..189649841 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,20 +1,20 @@
 use std::sync::Arc;
 
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SourceDatabase, CrateId, salsa};
+use ra_db::{SourceDatabase, salsa};
 
 use crate::{
     MacroCallId, HirFileId,
     SourceFileItems, SourceItemId, Crate, Module, HirInterner,
     query_definitions,
-    Function, FnSignature, FnScopes,
+    Function, FnSignature, ExprScopes,
     Struct, Enum, StructField,
     macros::MacroExpansion,
     module_tree::ModuleTree,
     nameres::{ItemMap, lower::{LoweredModule, ImportSourceMap}},
     ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef},
     adt::{StructData, EnumData},
-    impl_block::ModuleImplBlocks,
+    impl_block::{ModuleImplBlocks, ImplSourceMap},
     generics::{GenericParams, GenericDef},
     ids::SourceFileItemId,
 };
@@ -27,8 +27,8 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(crate::macros::expand_macro_invocation)]
     fn expand_macro_invocation(&self, invoc: MacroCallId) -> Option<Arc<MacroExpansion>>;
 
-    #[salsa::invoke(query_definitions::fn_scopes)]
-    fn fn_scopes(&self, func: Function) -> Arc<FnScopes>;
+    #[salsa::invoke(ExprScopes::expr_scopes_query)]
+    fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
 
     #[salsa::invoke(crate::adt::StructData::struct_data_query)]
     fn struct_data(&self, s: Struct) -> Arc<StructData>;
@@ -67,15 +67,24 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
     #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_source_map_query)]
     fn lower_module_source_map(&self, module: Module) -> Arc<ImportSourceMap>;
 
-    #[salsa::invoke(query_definitions::item_map)]
-    fn item_map(&self, crate_id: CrateId) -> Arc<ItemMap>;
+    #[salsa::invoke(crate::nameres::ItemMap::item_map_query)]
+    fn item_map(&self, krate: Crate) -> Arc<ItemMap>;
 
     #[salsa::invoke(crate::module_tree::ModuleTree::module_tree_query)]
-    fn module_tree(&self, crate_id: CrateId) -> Arc<ModuleTree>;
+    fn module_tree(&self, krate: Crate) -> Arc<ModuleTree>;
+
+    #[salsa::invoke(crate::impl_block::impls_in_module_with_source_map_query)]
+    fn impls_in_module_with_source_map(
+        &self,
+        module: Module,
+    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
 
     #[salsa::invoke(crate::impl_block::impls_in_module)]
     fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
 
+    #[salsa::invoke(crate::impl_block::impls_in_module_source_map_query)]
+    fn impls_in_module_source_map(&self, module: Module) -> Arc<ImplSourceMap>;
+
     #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
     fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
 
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 60d997bbe..37aa24677 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -16,6 +16,10 @@ use crate::{
 };
 use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
 
+pub use self::scope::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
+
+mod scope;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
 impl_arena_id!(ExprId);
@@ -215,7 +219,7 @@ pub use ra_syntax::ast::BinOp as BinaryOp;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MatchArm {
     pub pats: Vec<PatId>,
-    // guard: Option<ExprId>, // TODO
+    pub guard: Option<ExprId>,
     pub expr: ExprId,
 }
 
@@ -511,10 +515,12 @@ impl ExprCollector {
                         MatchArm {
                             pats: vec![pat],
                             expr: then_branch,
+                            guard: None,
                         },
                         MatchArm {
                             pats: vec![placeholder_pat],
                             expr: else_branch,
+                            guard: None,
                         },
                     ];
                     self.alloc_expr(
@@ -613,6 +619,10 @@ impl ExprCollector {
                         .map(|arm| MatchArm {
                             pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
                             expr: self.collect_expr_opt(arm.expr()),
+                            guard: arm
+                                .guard()
+                                .and_then(|guard| guard.expr())
+                                .map(|e| self.collect_expr(e)),
                         })
                         .collect()
                 } else {
diff --git a/crates/ra_hir/src/code_model_impl/function/scope.rs b/crates/ra_hir/src/expr/scope.rs
index c5d1de5eb..f8b5ba581 100644
--- a/crates/ra_hir/src/code_model_impl/function/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -9,14 +9,18 @@ use ra_syntax::{
 };
 use ra_arena::{Arena, RawId, impl_arena_id};
 
-use crate::{Name, AsName, expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping}};
+use crate::{
+    Name, AsName, Function,
+    expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping},
+    db::HirDatabase,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ScopeId(RawId);
 impl_arena_id!(ScopeId);
 
 #[derive(Debug, PartialEq, Eq)]
-pub struct FnScopes {
+pub struct ExprScopes {
     body: Arc<Body>,
     scopes: Arena<ScopeId, ScopeData>,
     scope_for: FxHashMap<ExprId, ScopeId>,
@@ -34,9 +38,16 @@ pub struct ScopeData {
     entries: Vec<ScopeEntry>,
 }
 
-impl FnScopes {
-    pub(crate) fn new(body: Arc<Body>) -> FnScopes {
-        let mut scopes = FnScopes {
+impl ExprScopes {
+    // TODO: This should take something more general than Function
+    pub(crate) fn expr_scopes_query(db: &impl HirDatabase, function: Function) -> Arc<ExprScopes> {
+        let body = db.body_hir(function);
+        let res = ExprScopes::new(body);
+        Arc::new(res)
+    }
+
+    fn new(body: Arc<Body>) -> ExprScopes {
+        let mut scopes = ExprScopes {
             body: body.clone(),
             scopes: Arena::default(),
             scope_for: FxHashMap::default(),
@@ -119,7 +130,7 @@ impl FnScopes {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ScopesWithSyntaxMapping {
     pub syntax_mapping: Arc<BodySyntaxMapping>,
-    pub scopes: Arc<FnScopes>,
+    pub scopes: Arc<ExprScopes>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -249,7 +260,7 @@ fn compute_block_scopes(
     statements: &[Statement],
     tail: Option<ExprId>,
     body: &Body,
-    scopes: &mut FnScopes,
+    scopes: &mut ExprScopes,
     mut scope: ScopeId,
 ) {
     for stmt in statements {
@@ -275,7 +286,7 @@ fn compute_block_scopes(
     }
 }
 
-fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut FnScopes, scope: ScopeId) {
+fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) {
     scopes.set_scope(expr, scope);
     match &body[expr] {
         Expr::Block { statements, tail } => {
@@ -344,7 +355,7 @@ mod tests {
         let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
         let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
         let body_hir = expr::collect_fn_body_syntax(fn_def);
-        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
         let scopes = ScopesWithSyntaxMapping {
             scopes: Arc::new(scopes),
             syntax_mapping: Arc::new(body_hir),
@@ -444,7 +455,7 @@ mod tests {
         let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
 
         let body_hir = expr::collect_fn_body_syntax(fn_def);
-        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
         let scopes = ScopesWithSyntaxMapping {
             scopes: Arc::new(scopes),
             syntax_mapping: Arc::new(body_hir),
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 222e47349..5fc26324a 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,8 +1,10 @@
 use std::sync::Arc;
 use rustc_hash::FxHashMap;
 
-use ra_arena::{Arena, RawId, impl_arena_id};
-use ra_syntax::ast::{self, AstNode};
+use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
+use ra_syntax::{
+    AstPtr, SourceFile, TreeArc,
+ast::{self, AstNode}};
 
 use crate::{
     Const, Type,
@@ -14,6 +16,26 @@ use crate::{
 
 use crate::code_model_api::{Module, ModuleSource};
 
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ImplSourceMap {
+    map: ArenaMap<ImplId, AstPtr<ast::ImplBlock>>,
+}
+
+impl ImplSourceMap {
+    fn insert(&mut self, impl_id: ImplId, impl_block: &ast::ImplBlock) {
+        self.map.insert(impl_id, AstPtr::new(impl_block))
+    }
+
+    pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> TreeArc<ast::ImplBlock> {
+        let file = match source {
+            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
+        };
+
+        self.map[impl_id].to_node(file).to_owned()
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImplBlock {
     module_impl_blocks: Arc<ModuleImplBlocks>,
@@ -39,6 +61,10 @@ impl ImplBlock {
         }
     }
 
+    pub fn id(&self) -> ImplId {
+        self.impl_id
+    }
+
     fn impl_data(&self) -> &ImplData {
         &self.module_impl_blocks.impls[self.impl_id]
     }
@@ -148,7 +174,7 @@ impl ModuleImplBlocks {
         }
     }
 
-    fn collect(&mut self, db: &impl HirDatabase, module: Module) {
+    fn collect(&mut self, db: &impl HirDatabase, module: Module, source_map: &mut ImplSourceMap) {
         let (file_id, module_source) = module.definition_source(db);
         let file_id: HirFileId = file_id.into();
         let node = match &module_source {
@@ -165,12 +191,31 @@ impl ModuleImplBlocks {
             for &impl_item in &self.impls[id].items {
                 self.impls_by_def.insert(impl_item, id);
             }
+
+            source_map.insert(id, impl_block_ast);
         }
     }
 }
 
-pub(crate) fn impls_in_module(db: &impl HirDatabase, module: Module) -> Arc<ModuleImplBlocks> {
+pub(crate) fn impls_in_module_with_source_map_query(
+    db: &impl HirDatabase,
+    module: Module,
+) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
+    let mut source_map = ImplSourceMap::default();
+
     let mut result = ModuleImplBlocks::new();
-    result.collect(db, module);
-    Arc::new(result)
+    result.collect(db, module, &mut source_map);
+
+    (Arc::new(result), Arc::new(source_map))
+}
+
+pub(crate) fn impls_in_module(db: &impl HirDatabase, module: Module) -> Arc<ModuleImplBlocks> {
+    db.impls_in_module_with_source_map(module).0
+}
+
+pub(crate) fn impls_in_module_source_map_query(
+    db: &impl HirDatabase,
+    module: Module,
+) -> Arc<ImplSourceMap> {
+    db.impls_in_module_with_source_map(module).1
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index eaf8565ee..0b9ee63bf 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -57,9 +57,9 @@ pub use self::{
     nameres::{ItemMap, PerNs, Namespace, Resolution},
     ty::Ty,
     impl_block::{ImplBlock, ImplItem},
-    code_model_impl::function::{FnScopes, ScopesWithSyntaxMapping},
     docs::{Docs, Documentation},
     adt::AdtDef,
+    expr::{ExprScopes, ScopesWithSyntaxMapping},
 };
 
 pub use self::code_model_api::{
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index 893c375b5..1f327eeb2 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use arrayvec::ArrayVec;
 use relative_path::RelativePathBuf;
-use ra_db::{FileId, SourceRoot, CrateId};
+use ra_db::{FileId, SourceRoot};
 use ra_syntax::{
     SyntaxNode, TreeArc,
     algo::generate,
@@ -13,6 +13,7 @@ use test_utils::tested_by;
 
 use crate::{
     Name, AsName, HirDatabase, SourceItemId, HirFileId, Problem, SourceFileItems, ModuleSource,
+    Crate,
     ids::SourceFileItemId,
 };
 
@@ -132,10 +133,10 @@ struct LinkData {
 }
 
 impl ModuleTree {
-    pub(crate) fn module_tree_query(db: &impl HirDatabase, crate_id: CrateId) -> Arc<ModuleTree> {
+    pub(crate) fn module_tree_query(db: &impl HirDatabase, krate: Crate) -> Arc<ModuleTree> {
         db.check_canceled();
         let mut res = ModuleTree::default();
-        res.init_crate(db, crate_id);
+        res.init_crate(db, krate);
         Arc::new(res)
     }
 
@@ -155,9 +156,9 @@ impl ModuleTree {
         Some(res)
     }
 
-    fn init_crate(&mut self, db: &impl HirDatabase, crate_id: CrateId) {
+    fn init_crate(&mut self, db: &impl HirDatabase, krate: Crate) {
         let crate_graph = db.crate_graph();
-        let file_id = crate_graph.crate_root(crate_id);
+        let file_id = crate_graph.crate_root(krate.crate_id);
         let source_root_id = db.file_source_root(file_id);
 
         let source_root = db.source_root(source_root_id);
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 97ce6c946..4573a72ba 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -16,9 +16,8 @@
 //! structure itself is modified.
 pub(crate) mod lower;
 
-use std::sync::Arc;
+use std::{time, sync::Arc};
 
-use ra_db::CrateId;
 use ra_arena::map::ArenaMap;
 use test_utils::tested_by;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -156,10 +155,10 @@ impl<T> PerNs<T> {
     }
 }
 
-pub(crate) struct Resolver<'a, DB> {
+struct Resolver<'a, DB> {
     db: &'a DB,
     input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-    krate: CrateId,
+    krate: Crate,
     module_tree: Arc<ModuleTree>,
     processed_imports: FxHashSet<(ModuleId, ImportId)>,
     result: ItemMap,
@@ -169,10 +168,10 @@ impl<'a, DB> Resolver<'a, DB>
 where
     DB: HirDatabase,
 {
-    pub(crate) fn new(
+    fn new(
         db: &'a DB,
         input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-        krate: CrateId,
+        krate: Crate,
     ) -> Resolver<'a, DB> {
         let module_tree = db.module_tree(krate);
         Resolver {
@@ -219,7 +218,7 @@ where
             let crate_graph = self.db.crate_graph();
             if let Some(crate_id) = crate_graph.crate_id_for_crate_root(file_id.as_original_file())
             {
-                let krate = Crate::new(crate_id);
+                let krate = Crate { crate_id };
                 for dep in krate.dependencies(self.db) {
                     if let Some(module) = dep.krate.root_module(self.db) {
                         let def = module.into();
@@ -331,6 +330,26 @@ enum ReachedFixedPoint {
 }
 
 impl ItemMap {
+    pub(crate) fn item_map_query(db: &impl HirDatabase, krate: Crate) -> Arc<ItemMap> {
+        let start = time::Instant::now();
+        let module_tree = db.module_tree(krate);
+        let input = module_tree
+            .modules()
+            .map(|module_id| {
+                (
+                    module_id,
+                    db.lower_module_module(Module { krate, module_id }),
+                )
+            })
+            .collect::<FxHashMap<_, _>>();
+
+        let resolver = Resolver::new(db, &input, krate);
+        let res = resolver.resolve();
+        let elapsed = start.elapsed();
+        log::info!("item_map: {:?}", elapsed);
+        Arc::new(res)
+    }
+
     pub(crate) fn resolve_path(
         &self,
         db: &impl HirDatabase,
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 3d420467c..9c5ca097e 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -16,7 +16,7 @@ fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
     let module = crate::source_binder::module_from_position(&db, pos).unwrap();
     let krate = module.krate(&db).unwrap();
     let module_id = module.module_id;
-    (db.item_map(krate.crate_id), module_id)
+    (db.item_map(krate), module_id)
 }
 
 /// Sets the crate root to the file of the cursor marker
@@ -30,7 +30,7 @@ fn item_map_custom_crate_root(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
     let module = crate::source_binder::module_from_position(&db, pos).unwrap();
     let krate = module.krate(&db).unwrap();
     let module_id = module.module_id;
-    (db.item_map(krate.crate_id), module_id)
+    (db.item_map(krate), module_id)
 }
 
 fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
@@ -297,7 +297,7 @@ fn item_map_across_crates() {
 
     let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
 
     check_module_item_map(
         &item_map,
@@ -349,7 +349,7 @@ fn import_across_source_roots() {
 
     let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
 
     check_module_item_map(
         &item_map,
@@ -391,7 +391,7 @@ fn reexport_across_crates() {
 
     let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
     let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
 
     check_module_item_map(
         &item_map,
@@ -409,7 +409,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
     let krate = module.krate(&db).unwrap();
     {
         let events = db.log_executed(|| {
-            db.item_map(krate.crate_id);
+            db.item_map(krate);
         });
         assert!(format!("{:?}", events).contains("item_map"))
     }
@@ -417,7 +417,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
 
     {
         let events = db.log_executed(|| {
-            db.item_map(krate.crate_id);
+            db.item_map(krate);
         });
         assert!(
             !format!("{:?}", events).contains("item_map"),
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index bf9ac0dfb..734a98282 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -1,25 +1,14 @@
-use std::{
-    sync::Arc,
-    time::Instant,
-};
+use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
-use ra_syntax::{SyntaxNode, TreeArc};
-use ra_db::{CrateId};
+use ra_syntax::{
+    SyntaxNode, TreeArc,
+};
 
 use crate::{
     SourceFileItems, SourceItemId, HirFileId,
-    Function, FnScopes, Module,
     db::HirDatabase,
-    nameres::{ItemMap, Resolver},
 };
 
-pub(super) fn fn_scopes(db: &impl HirDatabase, func: Function) -> Arc<FnScopes> {
-    let body = db.body_hir(func);
-    let res = FnScopes::new(body);
-    Arc::new(res)
-}
-
 pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
     let source_file = db.hir_parse(file_id);
     let res = SourceFileItems::new(file_id, &source_file);
@@ -35,26 +24,3 @@ pub(super) fn file_item(
         .to_node(&source_file)
         .to_owned()
 }
-
-pub(super) fn item_map(db: &impl HirDatabase, crate_id: CrateId) -> Arc<ItemMap> {
-    let start = Instant::now();
-    let module_tree = db.module_tree(crate_id);
-    let input = module_tree
-        .modules()
-        .map(|module_id| {
-            (
-                module_id,
-                db.lower_module_module(Module {
-                    krate: crate_id,
-                    module_id,
-                }),
-            )
-        })
-        .collect::<FxHashMap<_, _>>();
-
-    let resolver = Resolver::new(db, &input, crate_id);
-    let res = resolver.resolve();
-    let elapsed = start.elapsed();
-    log::info!("item_map: {:?}", elapsed);
-    Arc::new(res)
-}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index f523f0647..d1eaccf23 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -13,8 +13,8 @@ use ra_syntax::{
 };
 
 use crate::{
-    HirDatabase, Function, ModuleDef,
-    AsName, Module, HirFileId,
+    HirDatabase, Function, ModuleDef, Struct, Enum,
+    AsName, Module, HirFileId, Crate,
     ids::{LocationCtx, SourceFileItemId},
 };
 
@@ -83,7 +83,8 @@ fn module_from_source(
     let source_root_id = db.file_source_root(file_id.as_original_file());
     db.source_root_crates(source_root_id)
         .iter()
-        .find_map(|&krate| {
+        .map(|&crate_id| Crate { crate_id })
+        .find_map(|krate| {
             let module_tree = db.module_tree(krate);
             let module_id = module_tree.find_module_by_source(file_id, decl_id)?;
             Some(Module { krate, module_id })
@@ -128,6 +129,28 @@ pub fn function_from_child_node(
     function_from_source(db, file_id, fn_def)
 }
 
+pub fn struct_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    struct_def: &ast::StructDef,
+) -> Struct {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Struct {
+        id: ctx.to_def(struct_def),
+    }
+}
+
+pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Enum {
+        id: ctx.to_def(enum_def),
+    }
+}
+
 pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, TextRange)> {
     let module = match module_from_file_id(db, file_id) {
         Some(it) => it,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 7a5485698..60c231e82 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -34,7 +34,7 @@ use test_utils::tested_by;
 
 use crate::{
     Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
-    FnSignature, FnScopes, ModuleDef, AdtDef,
+    FnSignature, ExprScopes, ModuleDef, AdtDef,
     db::HirDatabase,
     type_ref::{TypeRef, Mutability},
     name::KnownName,
@@ -814,7 +814,7 @@ impl Index<PatId> for InferenceResult {
 struct InferenceContext<'a, D: HirDatabase> {
     db: &'a D,
     body: Arc<Body>,
-    scopes: Arc<FnScopes>,
+    scopes: Arc<ExprScopes>,
     module: Module,
     impl_block: Option<ImplBlock>,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
@@ -908,7 +908,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     fn new(
         db: &'a D,
         body: Arc<Body>,
-        scopes: Arc<FnScopes>,
+        scopes: Arc<ExprScopes>,
         module: Module,
         impl_block: Option<ImplBlock>,
     ) -> Self {
@@ -1488,7 +1488,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                     for &pat in &arm.pats {
                         let _pat_ty = self.infer_pat(pat, &input_ty);
                     }
-                    // TODO type the guard
+                    if let Some(guard_expr) = arm.guard {
+                        self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
+                    }
                     self.infer_expr(arm.expr, &expected);
                 }
 
@@ -1561,9 +1563,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 cast_ty
             }
             Expr::Ref { expr, mutability } => {
-                // TODO pass the expectation down
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty {
+                    if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                        // TODO: throw type error - expected mut reference but found shared ref,
+                        // which cannot be coerced
+                    }
+                    Expectation::has_type((**subty).clone())
+                } else {
+                    Expectation::none()
+                };
                 // TODO reference coercions etc.
+                let inner_ty = self.infer_expr(*expr, &expectation);
                 Ty::Ref(Arc::new(inner_ty), *mutability)
             }
             Expr::UnaryOp { expr, op } => {
@@ -1720,7 +1730,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
     db.check_canceled();
     let body = func.body(db);
-    let scopes = db.fn_scopes(func);
+    let scopes = db.expr_scopes(func);
     let module = func.module(db);
     let impl_block = func.impl_block(db);
     let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 9a571c2aa..37bc3f38c 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -44,7 +44,7 @@ impl CrateImplBlocks {
         &'a self,
         db: &'a impl HirDatabase,
         ty: &Ty,
-    ) -> impl Iterator<Item = ImplBlock> + 'a {
+    ) -> impl Iterator<Item = (Module, ImplBlock)> + 'a {
         let fingerprint = TyFingerprint::for_impl(ty);
         fingerprint
             .and_then(|f| self.impls.get(&f))
@@ -52,11 +52,11 @@ impl CrateImplBlocks {
             .flat_map(|i| i.iter())
             .map(move |(module_id, impl_id)| {
                 let module = Module {
-                    krate: self.krate.crate_id,
+                    krate: self.krate,
                     module_id: *module_id,
                 };
                 let module_impl_blocks = db.impls_in_module(module);
-                ImplBlock::from_id(module_impl_blocks, *impl_id)
+                (module, ImplBlock::from_id(module_impl_blocks, *impl_id))
             })
     }
 
@@ -152,7 +152,7 @@ impl Ty {
             };
             let impls = db.impls_in_crate(krate);
 
-            for impl_block in impls.lookup_impl_blocks(db, &derefed_ty) {
+            for (_, impl_block) in impls.lookup_impl_blocks(db, &derefed_ty) {
                 for item in impl_block.items() {
                     match item {
                         ImplItem::Method(f) => {
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
index 2719f592e..48c83cbb2 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
@@ -1,10 +1,10 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: insta@0.4.0
+created: "2019-01-28T21:58:55.559331849+00:00"
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
-[68; 262) '{     ...  d; }': ()
+[68; 289) '{     ...  d; }': ()
 [78; 79) 'e': E
 [82; 95) 'E::A { x: 3 }': E
 [92; 93) '3': usize
@@ -15,15 +15,18 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [129; 148) 'E::A {..._var }': E
 [139; 146) 'new_var': usize
 [151; 152) 'e': E
-[159; 218) 'match ...     }': usize
+[159; 245) 'match ...     }': usize
 [165; 166) 'e': E
 [177; 187) 'E::A { x }': E
 [184; 185) 'x': usize
 [191; 192) 'x': usize
 [202; 206) 'E::B': E
-[210; 211) '1': usize
-[229; 248) 'ref d ...{ .. }': &E
-[237; 248) 'E::A { .. }': E
-[251; 252) 'e': E
-[258; 259) 'd': &E
+[210; 213) 'foo': bool
+[217; 218) '1': usize
+[228; 232) 'E::B': E
+[236; 238) '10': usize
+[256; 275) 'ref d ...{ .. }': &E
+[264; 275) 'E::A { .. }': E
+[278; 279) 'e': E
+[285; 286) 'd': &E
 
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
index 3f2faa598..042248c35 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
@@ -1,12 +1,12 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
-creator: insta@0.4.0
+created: "2019-01-30T20:08:05.185312835+00:00"
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [9; 10) 'x': &str
 [18; 19) 'y': isize
-[28; 293) '{     ... []; }': ()
+[28; 324) '{     ... 3]; }': ()
 [38; 39) 'a': [&str]
 [42; 45) '[x]': [&str]
 [43; 44) 'x': &str
@@ -56,4 +56,10 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [260; 263) '"b"': &str
 [275; 276) 'x': [u8]
 [288; 290) '[]': [u8]
+[300; 301) 'z': &[u8]
+[311; 321) '&[1, 2, 3]': &[u8]
+[312; 321) '[1, 2, 3]': [u8]
+[313; 314) '1': u8
+[316; 317) '2': u8
+[319; 320) '3': u8
 
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index b36e6ec47..cb8d6351d 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -371,6 +371,7 @@ fn test(x: &str, y: isize) {
 
     let b = [a, ["b"]];
     let x: [u8; 0] = [];
+    let z: &[u8] = &[1, 2, 3];
 }
 "#,
     );
@@ -426,7 +427,8 @@ fn test() {
 
     match e {
         E::A { x } => x,
-        E::B => 1,
+        E::B if foo => 1,
+        E::B => 10,
     };
 
     let ref d @ E::A { .. } = e;
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index ee1e13799..2eb388e0e 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -3,9 +3,10 @@ use ra_db::SourceDatabase;
 use ra_syntax::{
     AstNode, SyntaxNode, TextUnit, TextRange,
     SyntaxKind::FN_DEF,
-    ast::{self, ArgListOwner, DocCommentsOwner},
+    ast::{self, ArgListOwner},
     algo::find_node_at_offset,
 };
+use hir::Docs;
 
 use crate::{FilePosition, CallInfo, db::RootDatabase};
 
@@ -26,7 +27,9 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     let fn_file = db.parse(symbol.file_id);
     let fn_def = symbol.ptr.to_node(&fn_file);
     let fn_def = ast::FnDef::cast(fn_def).unwrap();
-    let mut call_info = CallInfo::new(fn_def)?;
+    let function = hir::source_binder::function_from_source(db, symbol.file_id, fn_def)?;
+
+    let mut call_info = CallInfo::new(db, function, fn_def)?;
     // If we have a calling expression let's find which argument we are on
     let num_params = call_info.parameters.len();
     let has_self = fn_def.param_list().and_then(|l| l.self_param()).is_some();
@@ -110,46 +113,13 @@ impl<'a> FnCallNode<'a> {
 }
 
 impl CallInfo {
-    fn new(node: &ast::FnDef) -> Option<Self> {
-        let label: String = if let Some(body) = node.body() {
-            let body_range = body.syntax().range();
-            let label: String = node
-                .syntax()
-                .children()
-                .filter(|child| !child.range().is_subrange(&body_range)) // Filter out body
-                .filter(|child| ast::Comment::cast(child).is_none()) // Filter out doc comments
-                .map(|node| node.text().to_string())
-                .collect();
-            label
-        } else {
-            node.syntax().text().to_string()
-        };
-
-        let mut doc = None;
-        if let Some(docs) = node.doc_comment_text() {
-            // Massage markdown
-            let mut processed_lines = Vec::new();
-            let mut in_code_block = false;
-            for line in docs.lines() {
-                if line.starts_with("```") {
-                    in_code_block = !in_code_block;
-                }
-
-                let line = if in_code_block && line.starts_with("```") && !line.contains("rust") {
-                    "```rust".into()
-                } else {
-                    line.to_string()
-                };
-
-                processed_lines.push(line);
-            }
-
-            doc = Some(processed_lines.join("\n"));
-        }
+    fn new(db: &RootDatabase, function: hir::Function, node: &ast::FnDef) -> Option<Self> {
+        let label = crate::completion::function_label(node)?;
+        let doc = function.docs(db);
 
         Some(CallInfo {
             parameters: param_list(node),
-            label: label.trim().to_owned(),
+            label,
             doc,
             active_parameter: None,
         })
@@ -284,7 +254,7 @@ fn bar() {
         assert_eq!(info.parameters, vec!["j".to_string()]);
         assert_eq!(info.active_parameter, Some(0));
         assert_eq!(info.label, "fn foo(j: u32) -> u32".to_string());
-        assert_eq!(info.doc, Some("test".into()));
+        assert_eq!(info.doc.map(|it| it.into()), Some("test".to_string()));
     }
 
     #[test]
@@ -313,18 +283,18 @@ pub fn do() {
         assert_eq!(info.active_parameter, Some(0));
         assert_eq!(info.label, "pub fn add_one(x: i32) -> i32".to_string());
         assert_eq!(
-            info.doc,
+            info.doc.map(|it| it.into()),
             Some(
                 r#"Adds one to the number given.
 
 # Examples
 
-```rust
+```
 let five = 5;
 
 assert_eq!(6, my_crate::add_one(5));
 ```"#
-                    .into()
+                    .to_string()
             )
         );
     }
@@ -359,18 +329,18 @@ pub fn do_it() {
         assert_eq!(info.active_parameter, Some(0));
         assert_eq!(info.label, "pub fn add_one(x: i32) -> i32".to_string());
         assert_eq!(
-            info.doc,
+            info.doc.map(|it| it.into()),
             Some(
                 r#"Adds one to the number given.
 
 # Examples
 
-```rust
+```
 let five = 5;
 
 assert_eq!(6, my_crate::add_one(5));
 ```"#
-                    .into()
+                    .to_string()
             )
         );
     }
@@ -414,12 +384,12 @@ pub fn foo() {
         );
         assert_eq!(info.active_parameter, Some(1));
         assert_eq!(
-            info.doc,
+            info.doc.map(|it| it.into()),
             Some(
                 r#"Method is called when writer finishes.
 
 By default this method stops actor's `Context`."#
-                    .into()
+                    .to_string()
             )
         );
     }
diff --git a/crates/ra_ide_api/src/completion.rs b/crates/ra_ide_api/src/completion.rs
index b1867de42..722d94f3a 100644
--- a/crates/ra_ide_api/src/completion.rs
+++ b/crates/ra_ide_api/src/completion.rs
@@ -10,6 +10,7 @@ mod complete_scope;
 mod complete_postfix;
 
 use ra_db::SourceDatabase;
+use ra_syntax::ast::{self, AstNode};
 
 use crate::{
     db,
@@ -61,3 +62,21 @@ pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Opti
     complete_postfix::complete_postfix(&mut acc, &ctx);
     Some(acc)
 }
+
+pub fn function_label(node: &ast::FnDef) -> Option<String> {
+    let label: String = if let Some(body) = node.body() {
+        let body_range = body.syntax().range();
+        let label: String = node
+            .syntax()
+            .children()
+            .filter(|child| !child.range().is_subrange(&body_range)) // Filter out body
+            .filter(|child| ast::Comment::cast(child).is_none()) // Filter out comments
+            .map(|node| node.text().to_string())
+            .collect();
+        label
+    } else {
+        node.syntax().text().to_string()
+    };
+
+    Some(label.trim().to_owned())
+}
diff --git a/crates/ra_ide_api/src/completion/completion_item.rs b/crates/ra_ide_api/src/completion/completion_item.rs
index 49bd636a5..d3bc14894 100644
--- a/crates/ra_ide_api/src/completion/completion_item.rs
+++ b/crates/ra_ide_api/src/completion/completion_item.rs
@@ -1,12 +1,12 @@
 use hir::{Docs, Documentation};
-use ra_syntax::{
-    ast::{self, AstNode},
-    TextRange,
-};
+use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
 use test_utils::tested_by;
 
-use crate::completion::completion_context::CompletionContext;
+use crate::completion::{
+    completion_context::CompletionContext,
+    function_label,
+};
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
@@ -97,8 +97,8 @@ impl CompletionItem {
         self.detail.as_ref().map(|it| it.as_str())
     }
     /// A doc-comment
-    pub fn documentation(&self) -> Option<&str> {
-        self.documentation.as_ref().map(|it| it.contents())
+    pub fn documentation(&self) -> Option<Documentation> {
+        self.documentation.clone()
     }
     /// What string is used for filtering.
     pub fn lookup(&self) -> &str {
@@ -252,7 +252,7 @@ impl Builder {
             self.documentation = Some(docs);
         }
 
-        if let Some(label) = function_label(ctx, function) {
+        if let Some(label) = function_item_label(ctx, function) {
             self.detail = Some(label);
         }
 
@@ -292,24 +292,9 @@ impl Into<Vec<CompletionItem>> for Completions {
     }
 }
 
-fn function_label(ctx: &CompletionContext, function: hir::Function) -> Option<String> {
+fn function_item_label(ctx: &CompletionContext, function: hir::Function) -> Option<String> {
     let node = function.source(ctx.db).1;
-
-    let label: String = if let Some(body) = node.body() {
-        let body_range = body.syntax().range();
-        let label: String = node
-            .syntax()
-            .children()
-            .filter(|child| !child.range().is_subrange(&body_range)) // Filter out body
-            .filter(|child| ast::Comment::cast(child).is_none()) // Filter out comments
-            .map(|node| node.text().to_string())
-            .collect();
-        label
-    } else {
-        node.syntax().text().to_string()
-    };
-
-    Some(label.trim().to_owned())
+    function_label(&node)
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
new file mode 100644
index 000000000..469d56d63
--- /dev/null
+++ b/crates/ra_ide_api/src/impls.rs
@@ -0,0 +1,120 @@
+use ra_db::{SourceDatabase};
+use ra_syntax::{
+    AstNode, ast,
+    algo::find_node_at_offset,
+};
+use hir::{db::HirDatabase, source_binder};
+
+use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
+
+pub(crate) fn goto_implementation(
+    db: &RootDatabase,
+    position: FilePosition,
+) -> Option<RangeInfo<Vec<NavigationTarget>>> {
+    let file = db.parse(position.file_id);
+    let syntax = file.syntax();
+
+    let module = source_binder::module_from_position(db, position)?;
+    let krate = module.krate(db)?;
+
+    let node = find_node_at_offset::<ast::NominalDef>(syntax, position.offset)?;
+    let ty = match node.kind() {
+        ast::NominalDefKind::StructDef(def) => {
+            source_binder::struct_from_module(db, module, &def).ty(db)
+        }
+        ast::NominalDefKind::EnumDef(def) => {
+            source_binder::enum_from_module(db, module, &def).ty(db)
+        }
+    };
+
+    let impls = db.impls_in_crate(krate);
+
+    let navs = impls
+        .lookup_impl_blocks(db, &ty)
+        .map(|(module, imp)| NavigationTarget::from_impl_block(db, module, &imp));
+
+    Some(RangeInfo::new(node.syntax().range(), navs.collect()))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::mock_analysis::analysis_and_position;
+
+    fn check_goto(fixuture: &str, expected: &[&str]) {
+        let (analysis, pos) = analysis_and_position(fixuture);
+
+        let navs = analysis.goto_implementation(pos).unwrap().unwrap().info;
+        assert_eq!(navs.len(), expected.len());
+        navs.into_iter()
+            .enumerate()
+            .for_each(|(i, nav)| nav.assert_match(expected[i]));
+    }
+
+    #[test]
+    fn goto_implementation_works() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo<|>;
+            impl Foo {}
+            ",
+            &["impl IMPL_BLOCK FileId(1) [12; 23)"],
+        );
+    }
+
+    #[test]
+    fn goto_implementation_works_multiple_blocks() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo<|>;
+            impl Foo {}
+            impl Foo {}
+            ",
+            &[
+                "impl IMPL_BLOCK FileId(1) [12; 23)",
+                "impl IMPL_BLOCK FileId(1) [24; 35)",
+            ],
+        );
+    }
+
+    #[test]
+    fn goto_implementation_works_multiple_mods() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo<|>;
+            mod a {
+                impl super::Foo {}
+            }
+            mod b {
+                impl super::Foo {}
+            }
+            ",
+            &[
+                "impl IMPL_BLOCK FileId(1) [24; 42)",
+                "impl IMPL_BLOCK FileId(1) [57; 75)",
+            ],
+        );
+    }
+
+    #[test]
+    fn goto_implementation_works_multiple_files() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo<|>;
+            mod a;
+            mod b;
+            //- /a.rs
+            impl crate::Foo {}
+            //- /b.rs
+            impl crate::Foo {}
+            ",
+            &[
+                "impl IMPL_BLOCK FileId(2) [0; 18)",
+                "impl IMPL_BLOCK FileId(3) [0; 18)",
+            ],
+        );
+    }
+}
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 51947e4cc..5d8acf9df 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -25,6 +25,7 @@ mod call_info;
 mod syntax_highlighting;
 mod parent_module;
 mod rename;
+mod impls;
 
 #[cfg(test)]
 mod marks;
@@ -58,6 +59,7 @@ pub use ra_ide_api_light::{
 pub use ra_db::{
     Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId
 };
+pub use hir::Documentation;
 
 // We use jemalloc mainly to get heap usage statistics, actual performance
 // differnece is not measures.
@@ -266,7 +268,7 @@ impl<T> RangeInfo<T> {
 #[derive(Debug)]
 pub struct CallInfo {
     pub label: String,
-    pub doc: Option<String>,
+    pub doc: Option<Documentation>,
     pub parameters: Vec<String>,
     pub active_parameter: Option<usize>,
 }
@@ -415,6 +417,13 @@ impl Analysis {
         self.with_db(|db| goto_definition::goto_definition(db, position))
     }
 
+    pub fn goto_implementation(
+        &self,
+        position: FilePosition,
+    ) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
+        self.with_db(|db| impls::goto_implementation(db, position))
+    }
+
     /// Finds all usages of the reference at point.
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
         self.with_db(|db| db.find_all_refs(position))
diff --git a/crates/ra_ide_api/src/navigation_target.rs b/crates/ra_ide_api/src/navigation_target.rs
index d73d4afa7..5ccb5cc2e 100644
--- a/crates/ra_ide_api/src/navigation_target.rs
+++ b/crates/ra_ide_api/src/navigation_target.rs
@@ -147,6 +147,16 @@ impl NavigationTarget {
         }
     }
 
+    pub(crate) fn from_impl_block(
+        db: &RootDatabase,
+        module: hir::Module,
+        impl_block: &hir::ImplBlock,
+    ) -> NavigationTarget {
+        let (file_id, _) = module.definition_source(db);
+        let node = module.impl_source(db, impl_block.id());
+        NavigationTarget::from_syntax(file_id, "impl".into(), None, node.syntax())
+    }
+
     #[cfg(test)]
     pub(crate) fn assert_match(&self, expected: &str) {
         let actual = self.debug_render();
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index bca079d65..254624487 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -2,7 +2,7 @@ use lsp_types::{
     CodeActionProviderCapability, CodeLensOptions, CompletionOptions, DocumentOnTypeFormattingOptions,
     ExecuteCommandOptions, FoldingRangeProviderCapability, RenameOptions, RenameProviderCapability,
     ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextDocumentSyncOptions,
+    TextDocumentSyncOptions, ImplementationProviderCapability,
 };
 
 pub fn server_capabilities() -> ServerCapabilities {
@@ -26,7 +26,7 @@ pub fn server_capabilities() -> ServerCapabilities {
         }),
         definition_provider: Some(true),
         type_definition_provider: None,
-        implementation_provider: None,
+        implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
         references_provider: Some(true),
         document_highlight_provider: Some(true),
         document_symbol_provider: Some(true),
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 8c87f5195..c033ecdea 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -87,13 +87,6 @@ impl ConvWith for CompletionItem {
             None
         };
 
-        let documentation = self.documentation().map(|value| {
-            Documentation::MarkupContent(MarkupContent {
-                kind: MarkupKind::Markdown,
-                value: value.to_string(),
-            })
-        });
-
         let mut res = lsp_types::CompletionItem {
             label: self.label().to_string(),
             detail: self.detail().map(|it| it.to_string()),
@@ -101,7 +94,7 @@ impl ConvWith for CompletionItem {
             kind: self.kind().map(|it| it.conv()),
             text_edit: Some(text_edit),
             additional_text_edits,
-            documentation: documentation,
+            documentation: self.documentation().map(|it| it.conv()),
             ..Default::default()
         };
         res.insert_text_format = Some(match self.insert_text_format() {
@@ -160,6 +153,16 @@ impl ConvWith for Range {
     }
 }
 
+impl Conv for ra_ide_api::Documentation {
+    type Output = lsp_types::Documentation;
+    fn conv(self) -> Documentation {
+        Documentation::MarkupContent(MarkupContent {
+            kind: MarkupKind::Markdown,
+            value: crate::markdown::sanitize_markdown(self).into(),
+        })
+    }
+}
+
 impl ConvWith for TextEdit {
     type Ctx = LineIndex;
     type Output = Vec<lsp_types::TextEdit>;
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index f93d4b37d..5b5f3b948 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -2,6 +2,7 @@ mod caps;
 mod cargo_target_spec;
 mod conv;
 mod main_loop;
+mod markdown;
 mod project_model;
 pub mod req;
 mod server_world;
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index e430ac6de..df390c19e 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -305,6 +305,7 @@ fn on_request(
         .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)?
         .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
         .on::<req::GotoDefinition>(handlers::handle_goto_definition)?
+        .on::<req::GotoImplementation>(handlers::handle_goto_implementation)?
         .on::<req::ParentModule>(handlers::handle_parent_module)?
         .on::<req::Runnables>(handlers::handle_runnables)?
         .on::<req::DecorationsRequest>(handlers::handle_decorations)?
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 9478ebfb8..74554f15c 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -1,7 +1,7 @@
 use gen_lsp_server::ErrorCode;
 use lsp_types::{
     CodeActionResponse, CodeLens, Command, Diagnostic, DiagnosticSeverity,
-    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, Documentation, FoldingRange,
+    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
     FoldingRangeKind, FoldingRangeParams, Hover, HoverContents, Location, MarkupContent,
     MarkupKind, ParameterInformation, ParameterLabel, Position, PrepareRenameResponse, Range,
     RenameParams, SignatureInformation, SymbolInformation, TextDocumentIdentifier, TextEdit,
@@ -229,6 +229,26 @@ pub fn handle_goto_definition(
     Ok(Some(req::GotoDefinitionResponse::Link(res)))
 }
 
+pub fn handle_goto_implementation(
+    world: ServerWorld,
+    params: req::TextDocumentPositionParams,
+) -> Result<Option<req::GotoImplementationResponse>> {
+    let position = params.try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(position.file_id);
+    let nav_info = match world.analysis().goto_implementation(position)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+    let nav_range = nav_info.range;
+    let res = nav_info
+        .info
+        .into_iter()
+        .map(|nav| RangeInfo::new(nav_range, nav))
+        .map(|nav| to_location_link(&nav, &world, &line_index))
+        .collect::<Result<Vec<_>>>()?;
+    Ok(Some(req::GotoDefinitionResponse::Link(res)))
+}
+
 pub fn handle_parent_module(
     world: ServerWorld,
     params: req::TextDocumentPositionParams,
@@ -401,12 +421,9 @@ pub fn handle_signature_help(
                 documentation: None,
             })
             .collect();
-        let documentation = call_info.doc.map(|value| {
-            Documentation::MarkupContent(MarkupContent {
-                kind: MarkupKind::Markdown,
-                value,
-            })
-        });
+
+        let documentation = call_info.doc.map(|it| it.conv());
+
         let sig_info = SignatureInformation {
             label: call_info.label,
             documentation,
diff --git a/crates/ra_lsp_server/src/markdown.rs b/crates/ra_lsp_server/src/markdown.rs
new file mode 100644
index 000000000..f505755e8
--- /dev/null
+++ b/crates/ra_lsp_server/src/markdown.rs
@@ -0,0 +1,38 @@
+use ra_ide_api::Documentation;
+
+pub(crate) fn sanitize_markdown(docs: Documentation) -> Documentation {
+    let docs: String = docs.into();
+
+    // Massage markdown
+    let mut processed_lines = Vec::new();
+    let mut in_code_block = false;
+    for line in docs.lines() {
+        if line.starts_with("```") {
+            in_code_block = !in_code_block;
+        }
+
+        let line = if in_code_block && line.starts_with("```") && !line.contains("rust") {
+            "```rust".into()
+        } else {
+            line.to_string()
+        };
+
+        processed_lines.push(line);
+    }
+
+    Documentation::new(&processed_lines.join("\n"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_codeblock_adds_rust() {
+        let comment = "```\nfn some_rust() {}\n```";
+        assert_eq!(
+            sanitize_markdown(Documentation::new(comment)).contents(),
+            "```rust\nfn some_rust() {}\n```"
+        );
+    }
+}
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index a4d890755..e224ede80 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -8,7 +8,7 @@ pub use lsp_types::{
     CompletionParams, CompletionResponse, DocumentOnTypeFormattingParams, DocumentSymbolParams,
     DocumentSymbolResponse, ExecuteCommandParams, Hover, InitializeResult,
     PublishDiagnosticsParams, ReferenceParams, SignatureHelp, TextDocumentEdit,
-    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams,
+    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams
 };
 
 pub enum AnalyzerStatus {}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 3ace6533c..4f5a96014 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1981,7 +1981,11 @@ impl ToOwned for MatchGuard {
 }
 
 
-impl MatchGuard {}
+impl MatchGuard {
+    pub fn expr(&self) -> Option<&Expr> {
+        super::child_opt(self)
+    }
+}
 
 // MethodCallExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 85fc79038..e4cad4eb3 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -418,7 +418,7 @@ Grammar(
             ],
             collections: [ [ "pats", "Pat" ] ]
         ),
-        "MatchGuard": (),
+        "MatchGuard": (options: ["Expr"]),
         "StructLit": (options: ["Path", "NamedFieldList", ["spread", "Expr"]]),
         "NamedFieldList": (collections: [ ["fields", "NamedField"] ]),
         "NamedField": (options: ["NameRef", "Expr"]),
diff --git a/crates/ra_syntax/src/grammar/expressions/atom.rs b/crates/ra_syntax/src/grammar/expressions/atom.rs
index 6d6d89f70..600774afd 100644
--- a/crates/ra_syntax/src/grammar/expressions/atom.rs
+++ b/crates/ra_syntax/src/grammar/expressions/atom.rs
@@ -360,8 +360,8 @@ fn match_arm(p: &mut Parser) -> BlockLike {
     while p.eat(PIPE) {
         patterns::pattern(p);
     }
-    if p.eat(IF_KW) {
-        expr(p);
+    if p.at(IF_KW) {
+        match_guard(p);
     }
     p.expect(FAT_ARROW);
     let ret = expr_stmt(p);
@@ -369,6 +369,20 @@ fn match_arm(p: &mut Parser) -> BlockLike {
     ret
 }
 
+// test match_guard
+// fn foo() {
+//     match () {
+//         _ if foo => (),
+//     }
+// }
+fn match_guard(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(IF_KW));
+    let m = p.start();
+    p.bump();
+    expr(p);
+    m.complete(p, MATCH_GUARD)
+}
+
 // test block_expr
 // fn foo() {
 //     {};
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt
index 98e7535a3..b44e61879 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt
@@ -37,32 +37,33 @@ SOURCE_FILE@[0; 167)
               PLACEHOLDER_PAT@[51; 52)
                 UNDERSCORE@[51; 52)
               WHITESPACE@[52; 53)
-              IF_KW@[53; 55)
-              WHITESPACE@[55; 56)
-              BIN_EXPR@[56; 77)
-                PATH_EXPR@[56; 60)
-                  PATH@[56; 60)
-                    PATH_SEGMENT@[56; 60)
-                      NAME_REF@[56; 60)
-                        IDENT@[56; 60) "Test"
-                WHITESPACE@[60; 61)
-                R_ANGLE@[61; 62)
-                WHITESPACE@[62; 63)
-                STRUCT_LIT@[63; 77)
-                  PATH@[63; 67)
-                    PATH_SEGMENT@[63; 67)
-                      NAME_REF@[63; 67)
-                        IDENT@[63; 67) "Test"
-                  NAMED_FIELD_LIST@[67; 77)
-                    L_CURLY@[67; 68)
-                    NAMED_FIELD@[68; 76)
-                      NAME_REF@[68; 73)
-                        IDENT@[68; 73) "field"
-                      COLON@[73; 74)
-                      WHITESPACE@[74; 75)
-                      LITERAL@[75; 76)
-                        INT_NUMBER@[75; 76) "0"
-                    R_CURLY@[76; 77)
+              MATCH_GUARD@[53; 77)
+                IF_KW@[53; 55)
+                WHITESPACE@[55; 56)
+                BIN_EXPR@[56; 77)
+                  PATH_EXPR@[56; 60)
+                    PATH@[56; 60)
+                      PATH_SEGMENT@[56; 60)
+                        NAME_REF@[56; 60)
+                          IDENT@[56; 60) "Test"
+                  WHITESPACE@[60; 61)
+                  R_ANGLE@[61; 62)
+                  WHITESPACE@[62; 63)
+                  STRUCT_LIT@[63; 77)
+                    PATH@[63; 67)
+                      PATH_SEGMENT@[63; 67)
+                        NAME_REF@[63; 67)
+                          IDENT@[63; 67) "Test"
+                    NAMED_FIELD_LIST@[67; 77)
+                      L_CURLY@[67; 68)
+                      NAMED_FIELD@[68; 76)
+                        NAME_REF@[68; 73)
+                          IDENT@[68; 73) "field"
+                        COLON@[73; 74)
+                        WHITESPACE@[74; 75)
+                        LITERAL@[75; 76)
+                          INT_NUMBER@[75; 76) "0"
+                      R_CURLY@[76; 77)
               WHITESPACE@[77; 78)
               FAT_ARROW@[78; 80)
               WHITESPACE@[80; 81)
@@ -82,13 +83,14 @@ SOURCE_FILE@[0; 167)
                 NAME@[97; 98)
                   IDENT@[97; 98) "Y"
               WHITESPACE@[98; 99)
-              IF_KW@[99; 101)
-              WHITESPACE@[101; 102)
-              PATH_EXPR@[102; 103)
-                PATH@[102; 103)
-                  PATH_SEGMENT@[102; 103)
-                    NAME_REF@[102; 103)
-                      IDENT@[102; 103) "Z"
+              MATCH_GUARD@[99; 103)
+                IF_KW@[99; 101)
+                WHITESPACE@[101; 102)
+                PATH_EXPR@[102; 103)
+                  PATH@[102; 103)
+                    PATH_SEGMENT@[102; 103)
+                      NAME_REF@[102; 103)
+                        IDENT@[102; 103) "Z"
               WHITESPACE@[103; 104)
               FAT_ARROW@[104; 106)
               WHITESPACE@[106; 107)
@@ -110,13 +112,14 @@ SOURCE_FILE@[0; 167)
                 NAME@[125; 126)
                   IDENT@[125; 126) "Y"
               WHITESPACE@[126; 127)
-              IF_KW@[127; 129)
-              WHITESPACE@[129; 130)
-              PATH_EXPR@[130; 131)
-                PATH@[130; 131)
-                  PATH_SEGMENT@[130; 131)
-                    NAME_REF@[130; 131)
-                      IDENT@[130; 131) "Z"
+              MATCH_GUARD@[127; 131)
+                IF_KW@[127; 129)
+                WHITESPACE@[129; 130)
+                PATH_EXPR@[130; 131)
+                  PATH@[130; 131)
+                    PATH_SEGMENT@[130; 131)
+                      NAME_REF@[130; 131)
+                        IDENT@[130; 131) "Z"
               WHITESPACE@[131; 132)
               FAT_ARROW@[132; 134)
               WHITESPACE@[134; 135)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.rs
new file mode 100644
index 000000000..f1bd72fc4
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    match () {
+        _ if foo => (),
+    }
+}
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.txt
new file mode 100644
index 000000000..27553882d
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0118_match_guard.txt
@@ -0,0 +1,47 @@
+SOURCE_FILE@[0; 58)
+  FN_DEF@[0; 57)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+    WHITESPACE@[8; 9)
+    BLOCK@[9; 57)
+      L_CURLY@[9; 10)
+      WHITESPACE@[10; 15)
+      MATCH_EXPR@[15; 55)
+        MATCH_KW@[15; 20)
+        WHITESPACE@[20; 21)
+        TUPLE_EXPR@[21; 23)
+          L_PAREN@[21; 22)
+          R_PAREN@[22; 23)
+        WHITESPACE@[23; 24)
+        MATCH_ARM_LIST@[24; 55)
+          L_CURLY@[24; 25)
+          WHITESPACE@[25; 34)
+          MATCH_ARM@[34; 48)
+            PLACEHOLDER_PAT@[34; 35)
+              UNDERSCORE@[34; 35)
+            WHITESPACE@[35; 36)
+            MATCH_GUARD@[36; 42)
+              IF_KW@[36; 38)
+              WHITESPACE@[38; 39)
+              PATH_EXPR@[39; 42)
+                PATH@[39; 42)
+                  PATH_SEGMENT@[39; 42)
+                    NAME_REF@[39; 42)
+                      IDENT@[39; 42) "foo"
+            WHITESPACE@[42; 43)
+            FAT_ARROW@[43; 45)
+            WHITESPACE@[45; 46)
+            TUPLE_EXPR@[46; 48)
+              L_PAREN@[46; 47)
+              R_PAREN@[47; 48)
+          COMMA@[48; 49)
+          WHITESPACE@[49; 54)
+          R_CURLY@[54; 55)
+      WHITESPACE@[55; 56)
+      R_CURLY@[56; 57)
+  WHITESPACE@[57; 58)
diff --git a/editors/code/package.json b/editors/code/package.json
index 05c67d822..1ed834d62 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -44,7 +44,9 @@
         "vscode": "^1.1.26"
     },
     "activationEvents": [
-        "onLanguage:rust"
+        "onLanguage:rust",
+        "onCommand:rust-analyzer.analyzerStatus",
+        "onCommand:rust-analyzer.collectGarbage"
     ],
     "main": "./out/extension",
     "contributes": {
@@ -73,35 +75,43 @@
         "commands": [
             {
                 "command": "rust-analyzer.syntaxTree",
-                "title": "rust-analyzer: syntax tree"
+                "title": "Show syntax tree for current file",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.extendSelection",
-                "title": "rust-analyzer: extend selection"
+                "title": "Extend selection",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.matchingBrace",
-                "title": "rust-analyzer: matching brace"
+                "title": "Find matching brace",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.parentModule",
-                "title": "rust-analyzer: parent module"
+                "title": "Locate parent module",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.joinLines",
-                "title": "rust-analyzer: join lines"
+                "title": "Join lines",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.run",
-                "title": "rust-analyzer: run"
+                "title": "Run",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.analyzerStatus",
-                "title": "rust-analyzer: status"
+                "title": "Status",
+                "category": "Rust Analyzer"
             },
             {
                 "command": "rust-analyzer.collectGarbage",
-                "title": "rust-analyzer: run gc"
+                "title": "Run garbage collection",
+                "category": "Rust Analyzer"
             }
         ],
         "keybindings": [
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index d9ae56420..c0f2ada76 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -118,7 +118,8 @@ export async function handleSingle(runnable: Runnable) {
     task.group = vscode.TaskGroup.Build;
     task.presentationOptions = {
         reveal: vscode.TaskRevealKind.Always,
-        panel: vscode.TaskPanelKind.Dedicated
+        panel: vscode.TaskPanelKind.Dedicated,
+        clear: true
     };
 
     return vscode.tasks.executeTask(task);