27 files changed, 528 insertions, 468 deletions

diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index d42a664b6..022cbd5a3 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -10,7 +10,7 @@ log = "0.4.5"
 relative-path = "0.4.0"
 rayon = "1.0.2"
 fst = "0.3.1"
-salsa = "0.9.1"
+salsa = "0.9.2"
 rustc-hash = "1.0"
 parking_lot = "0.7.0"
 unicase = "2.2.0"
@@ -21,3 +21,6 @@ ra_text_edit = { path = "../ra_text_edit" }
 ra_db = { path = "../ra_db" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 test_utils = { path = "../test_utils" }
+
+[dev-dependencies]
+insta = "0.1.4"
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 27b760780..18b9508ef 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -1,6 +1,6 @@
 use std::cmp::{max, min};
 
-use ra_db::{SyntaxDatabase, Cancelable};
+use ra_db::SyntaxDatabase;
 use ra_syntax::{
     AstNode, SyntaxNode, TextUnit, TextRange,
     SyntaxKind::FN_DEF,
@@ -11,21 +11,23 @@ use ra_syntax::{
 use crate::{FilePosition, CallInfo, db::RootDatabase};
 
 /// Computes parameter information for the given call expression.
-pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Cancelable<Option<CallInfo>> {
+pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
     let file = db.source_file(position.file_id);
     let syntax = file.syntax();
 
     // Find the calling expression and it's NameRef
-    let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
-    let name_ref = ctry!(calling_node.name_ref());
+    let calling_node = FnCallNode::with_node(syntax, position.offset)?;
+    let name_ref = calling_node.name_ref()?;
 
     // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
-    let file_symbols = db.index_resolve(name_ref)?;
-    let symbol = ctry!(file_symbols.into_iter().find(|it| it.ptr.kind() == FN_DEF));
+    let file_symbols = db.index_resolve(name_ref);
+    let symbol = file_symbols
+        .into_iter()
+        .find(|it| it.ptr.kind() == FN_DEF)?;
     let fn_file = db.source_file(symbol.file_id);
     let fn_def = symbol.ptr.resolve(&fn_file);
     let fn_def = ast::FnDef::cast(&fn_def).unwrap();
-    let mut call_info = ctry!(CallInfo::new(fn_def));
+    let mut call_info = CallInfo::new(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();
@@ -61,7 +63,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Cancelable
         }
     }
 
-    Ok(Some(call_info))
+    Some(call_info)
 }
 
 enum FnCallNode<'a> {
diff --git a/crates/ra_ide_api/src/completion.rs b/crates/ra_ide_api/src/completion.rs
index ce777a771..b03ddd74c 100644
--- a/crates/ra_ide_api/src/completion.rs
+++ b/crates/ra_ide_api/src/completion.rs
@@ -12,7 +12,7 @@ use ra_db::SyntaxDatabase;
 
 use crate::{
     db,
-    Cancelable, FilePosition,
+    FilePosition,
     completion::{
         completion_item::{Completions, CompletionKind},
         completion_context::CompletionContext,
@@ -43,12 +43,9 @@ pub use crate::completion::completion_item::{CompletionItem, InsertText, Complet
 /// `foo` *should* be present among the completion variants. Filtering by
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
-pub(crate) fn completions(
-    db: &db::RootDatabase,
-    position: FilePosition,
-) -> Cancelable<Option<Completions>> {
+pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Option<Completions> {
     let original_file = db.source_file(position.file_id);
-    let ctx = ctry!(CompletionContext::new(db, &original_file, position)?);
+    let ctx = CompletionContext::new(db, &original_file, position)?;
 
     let mut acc = Completions::default();
 
@@ -57,11 +54,11 @@ pub(crate) fn completions(
     complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
     complete_snippet::complete_expr_snippet(&mut acc, &ctx);
     complete_snippet::complete_item_snippet(&mut acc, &ctx);
-    complete_path::complete_path(&mut acc, &ctx)?;
-    complete_scope::complete_scope(&mut acc, &ctx)?;
-    complete_dot::complete_dot(&mut acc, &ctx)?;
+    complete_path::complete_path(&mut acc, &ctx);
+    complete_scope::complete_scope(&mut acc, &ctx);
+    complete_dot::complete_dot(&mut acc, &ctx);
 
-    Ok(Some(acc))
+    Some(acc)
 }
 
 #[cfg(test)]
@@ -72,6 +69,6 @@ fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind
     } else {
         single_file_with_position(code)
     };
-    let completions = completions(&analysis.db, position).unwrap().unwrap();
+    let completions = completions(&analysis.db, position).unwrap();
     completions.assert_match(expected_completions, kind);
 }
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index 37985b398..473edc50e 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -1,41 +1,39 @@
 use hir::{Ty, Def};
 
-use crate::Cancelable;
 use crate::completion::{CompletionContext, Completions, CompletionKind, CompletionItem, CompletionItemKind};
 
 /// Complete dot accesses, i.e. fields or methods (currently only fields).
-pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     let (function, receiver) = match (&ctx.function, ctx.dot_receiver) {
         (Some(function), Some(receiver)) => (function, receiver),
-        _ => return Ok(()),
+        _ => return,
     };
-    let infer_result = function.infer(ctx.db)?;
-    let syntax_mapping = function.body_syntax_mapping(ctx.db)?;
+    let infer_result = function.infer(ctx.db);
+    let syntax_mapping = function.body_syntax_mapping(ctx.db);
     let expr = match syntax_mapping.node_expr(receiver) {
         Some(expr) => expr,
-        None => return Ok(()),
+        None => return,
     };
     let receiver_ty = infer_result[expr].clone();
     if !ctx.is_call {
-        complete_fields(acc, ctx, receiver_ty.clone())?;
+        complete_fields(acc, ctx, receiver_ty.clone());
     }
-    complete_methods(acc, ctx, receiver_ty)?;
-    Ok(())
+    complete_methods(acc, ctx, receiver_ty);
 }
 
-fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) -> Cancelable<()> {
+fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) {
     for receiver in receiver.autoderef(ctx.db) {
         match receiver {
             Ty::Adt { def_id, .. } => {
-                match def_id.resolve(ctx.db)? {
+                match def_id.resolve(ctx.db) {
                     Def::Struct(s) => {
-                        for field in s.fields(ctx.db)? {
+                        for field in s.fields(ctx.db) {
                             CompletionItem::new(
                                 CompletionKind::Reference,
                                 field.name().to_string(),
                             )
                             .kind(CompletionItemKind::Field)
-                            .set_detail(field.ty(ctx.db)?.map(|ty| ty.to_string()))
+                            .set_detail(field.ty(ctx.db).map(|ty| ty.to_string()))
                             .add_to(acc);
                         }
                     }
@@ -53,14 +51,9 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty)
             _ => {}
         };
     }
-    Ok(())
 }
 
-fn complete_methods(
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    receiver: Ty,
-) -> Cancelable<()> {
+fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) {
     receiver.iterate_methods(ctx.db, |func| {
         let sig = func.signature(ctx.db);
         if sig.has_self_param() {
@@ -69,9 +62,8 @@ fn complete_methods(
                 .kind(CompletionItemKind::Method)
                 .add_to(acc);
         }
-        Ok(None::<()>)
-    })?;
-    Ok(())
+        None::<()>
+    });
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs
index a25ad3f13..1eded7658 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -1,20 +1,19 @@
 use crate::{
-    Cancelable,
     completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext},
 };
 
-pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
     let (path, module) = match (&ctx.path_prefix, &ctx.module) {
         (Some(path), Some(module)) => (path.clone(), module),
-        _ => return Ok(()),
+        _ => return,
     };
-    let def_id = match module.resolve_path(ctx.db, &path)?.take_types() {
+    let def_id = match module.resolve_path(ctx.db, &path).take_types() {
         Some(it) => it,
-        None => return Ok(()),
+        None => return,
     };
-    match def_id.resolve(ctx.db)? {
+    match def_id.resolve(ctx.db) {
         hir::Def::Module(module) => {
-            let module_scope = module.scope(ctx.db)?;
+            let module_scope = module.scope(ctx.db);
             for (name, res) in module_scope.entries() {
                 CompletionItem::new(CompletionKind::Reference, name.to_string())
                     .from_resolution(ctx, res)
@@ -22,7 +21,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> C
             }
         }
         hir::Def::Enum(e) => {
-            e.variants(ctx.db)?
+            e.variants(ctx.db)
                 .into_iter()
                 .for_each(|(variant_name, _variant)| {
                     CompletionItem::new(CompletionKind::Reference, variant_name.to_string())
@@ -30,9 +29,8 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> C
                         .add_to(acc)
                 });
         }
-        _ => return Ok(()),
+        _ => return,
     };
-    Ok(())
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/completion/complete_scope.rs b/crates/ra_ide_api/src/completion/complete_scope.rs
index 770a0fdf2..699680748 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -1,26 +1,23 @@
 use rustc_hash::FxHashSet;
 use ra_syntax::TextUnit;
 
-use crate::{
-    Cancelable,
-    completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext},
-};
+use crate::completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext};
 
-pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.is_trivial_path {
-        return Ok(());
+        return;
     }
     let module = match &ctx.module {
         Some(it) => it,
-        None => return Ok(()),
+        None => return,
     };
     if let Some(function) = &ctx.function {
-        let scopes = function.scopes(ctx.db)?;
+        let scopes = function.scopes(ctx.db);
         complete_fn(acc, &scopes, ctx.offset);
     }
 
-    let module_scope = module.scope(ctx.db)?;
-    let (file_id, _) = module.definition_source(ctx.db)?;
+    let module_scope = module.scope(ctx.db);
+    let (file_id, _) = module.definition_source(ctx.db);
     module_scope
         .entries()
         .filter(|(_name, res)| {
@@ -40,7 +37,6 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) ->
                 .from_resolution(ctx, res)
                 .add_to(acc)
         });
-    Ok(())
 }
 
 fn complete_fn(acc: &mut Completions, scopes: &hir::ScopesWithSyntaxMapping, offset: TextUnit) {
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 113f6c070..e537e0082 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -7,7 +7,7 @@ use ra_syntax::{
 };
 use hir::source_binder;
 
-use crate::{db, FilePosition, Cancelable};
+use crate::{db, FilePosition};
 
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -41,10 +41,9 @@ impl<'a> CompletionContext<'a> {
         db: &'a db::RootDatabase,
         original_file: &'a SourceFile,
         position: FilePosition,
-    ) -> Cancelable<Option<CompletionContext<'a>>> {
-        let module = source_binder::module_from_position(db, position)?;
-        let leaf =
-            ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased());
+    ) -> Option<CompletionContext<'a>> {
+        let module = source_binder::module_from_position(db, position);
+        let leaf = find_leaf_at_offset(original_file.syntax(), position.offset).left_biased()?;
         let mut ctx = CompletionContext {
             db,
             leaf,
@@ -63,7 +62,7 @@ impl<'a> CompletionContext<'a> {
             is_call: false,
         };
         ctx.fill(original_file, position.offset);
-        Ok(Some(ctx))
+        Some(ctx)
     }
 
     fn fill(&mut self, original_file: &'a SourceFile, offset: TextUnit) {
diff --git a/crates/ra_ide_api/src/completion/completion_item.rs b/crates/ra_ide_api/src/completion/completion_item.rs
index b75d65de3..11d00f78c 100644
--- a/crates/ra_ide_api/src/completion/completion_item.rs
+++ b/crates/ra_ide_api/src/completion/completion_item.rs
@@ -144,7 +144,7 @@ impl Builder {
         ctx: &CompletionContext,
         resolution: &hir::Resolution,
     ) -> Builder {
-        let resolved = resolution.def_id.and_then(|d| d.resolve(ctx.db).ok());
+        let resolved = resolution.def_id.map(|d| d.resolve(ctx.db));
         let kind = match resolved {
             PerNs {
                 types: Some(hir::Def::Module(..)),
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index c3c809c9f..9f0ab2f1c 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -38,8 +38,9 @@ fn find_macro_call(node: &SyntaxNode, range: TextRange) -> Option<&ast::MacroCal
 
 #[cfg(test)]
 mod tests {
+    use ra_syntax::TextRange;
+
     use crate::mock_analysis::single_file_with_range;
-    use test_utils::assert_eq_dbg;
 
     #[test]
     fn extend_selection_inside_macros() {
@@ -51,6 +52,6 @@ mod tests {
         ",
         );
         let r = analysis.extend_selection(frange);
-        assert_eq_dbg("[51; 56)", &r);
+        assert_eq!(r, TextRange::from_to(51.into(), 56.into()));
     }
 }
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 332a2fb8d..b1becca03 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -1,4 +1,4 @@
-use ra_db::{FileId, Cancelable, SyntaxDatabase};
+use ra_db::{FileId, SyntaxDatabase};
 use ra_syntax::{
     AstNode, ast,
     algo::find_node_at_offset,
@@ -9,21 +9,18 @@ use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
 pub(crate) fn goto_definition(
     db: &RootDatabase,
     position: FilePosition,
-) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
+) -> Option<RangeInfo<Vec<NavigationTarget>>> {
     let file = db.source_file(position.file_id);
     let syntax = file.syntax();
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-        let navs = reference_definition(db, position.file_id, name_ref)?.to_vec();
-        return Ok(Some(RangeInfo::new(
-            name_ref.syntax().range(),
-            navs.to_vec(),
-        )));
+        let navs = reference_definition(db, position.file_id, name_ref).to_vec();
+        return Some(RangeInfo::new(name_ref.syntax().range(), navs.to_vec()));
     }
     if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
-        let navs = ctry!(name_definition(db, position.file_id, name)?);
-        return Ok(Some(RangeInfo::new(name.syntax().range(), navs)));
+        let navs = name_definition(db, position.file_id, name)?;
+        return Some(RangeInfo::new(name.syntax().range(), navs));
     }
-    Ok(None)
+    None
 }
 
 pub(crate) enum ReferenceResult {
@@ -45,16 +42,16 @@ pub(crate) fn reference_definition(
     db: &RootDatabase,
     file_id: FileId,
     name_ref: &ast::NameRef,
-) -> Cancelable<ReferenceResult> {
+) -> ReferenceResult {
     use self::ReferenceResult::*;
     if let Some(function) =
-        hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())?
+        hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())
     {
-        let scope = function.scopes(db)?;
+        let scope = function.scopes(db);
         // First try to resolve the symbol locally
         if let Some(entry) = scope.resolve_local_name(name_ref) {
             let nav = NavigationTarget::from_scope_entry(file_id, &entry);
-            return Ok(Exact(nav));
+            return Exact(nav);
         };
 
         // Next check if it is a method
@@ -63,22 +60,21 @@ pub(crate) fn reference_definition(
             .parent()
             .and_then(ast::MethodCallExpr::cast)
         {
-            let infer_result = function.infer(db)?;
-            let syntax_mapping = function.body_syntax_mapping(db)?;
+            let infer_result = function.infer(db);
+            let syntax_mapping = function.body_syntax_mapping(db);
             let expr = ast::Expr::cast(method_call.syntax()).unwrap();
             if let Some(def_id) = syntax_mapping
                 .node_expr(expr)
                 .and_then(|it| infer_result.method_resolution(it))
             {
-                if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)?)? {
-                    return Ok(Exact(target));
+                if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)) {
+                    return Exact(target);
                 }
             };
         }
     }
     // Then try module name resolution
-    if let Some(module) =
-        hir::source_binder::module_from_child_node(db, file_id, name_ref.syntax())?
+    if let Some(module) = hir::source_binder::module_from_child_node(db, file_id, name_ref.syntax())
     {
         if let Some(path) = name_ref
             .syntax()
@@ -86,39 +82,39 @@ pub(crate) fn reference_definition(
             .find_map(ast::Path::cast)
             .and_then(hir::Path::from_ast)
         {
-            let resolved = module.resolve_path(db, &path)?;
+            let resolved = module.resolve_path(db, &path);
             if let Some(def_id) = resolved.take_types().or(resolved.take_values()) {
-                if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)?)? {
-                    return Ok(Exact(target));
+                if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)) {
+                    return Exact(target);
                 }
             }
         }
     }
     // If that fails try the index based approach.
     let navs = db
-        .index_resolve(name_ref)?
+        .index_resolve(name_ref)
         .into_iter()
         .map(NavigationTarget::from_symbol)
         .collect();
-    Ok(Approximate(navs))
+    Approximate(navs)
 }
 
 fn name_definition(
     db: &RootDatabase,
     file_id: FileId,
     name: &ast::Name,
-) -> Cancelable<Option<Vec<NavigationTarget>>> {
+) -> Option<Vec<NavigationTarget>> {
     if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
         if module.has_semi() {
             if let Some(child_module) =
-                hir::source_binder::module_from_declaration(db, file_id, module)?
+                hir::source_binder::module_from_declaration(db, file_id, module)
             {
-                let nav = NavigationTarget::from_module(db, child_module)?;
-                return Ok(Some(vec![nav]));
+                let nav = NavigationTarget::from_module(db, child_module);
+                return Some(vec![nav]);
             }
         }
     }
-    Ok(None)
+    None
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index c445d4fa1..d91151c15 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -1,25 +1,22 @@
-use ra_db::{Cancelable, SyntaxDatabase};
+use ra_db::{SyntaxDatabase};
 use ra_syntax::{
     AstNode, SyntaxNode, TreeArc,
-    ast::{self, NameOwner},
+    ast::self,
     algo::{find_covering_node, find_node_at_offset, find_leaf_at_offset, visit::{visitor, Visitor}},
 };
 
 use crate::{db::RootDatabase, RangeInfo, FilePosition, FileRange, NavigationTarget};
 
-pub(crate) fn hover(
-    db: &RootDatabase,
-    position: FilePosition,
-) -> Cancelable<Option<RangeInfo<String>>> {
+pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<String>> {
     let file = db.source_file(position.file_id);
     let mut res = Vec::new();
 
     let mut range = None;
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
         use crate::goto_definition::{ReferenceResult::*, reference_definition};
-        let ref_result = reference_definition(db, position.file_id, name_ref)?;
+        let ref_result = reference_definition(db, position.file_id, name_ref);
         match ref_result {
-            Exact(nav) => res.extend(doc_text_for(db, nav)?),
+            Exact(nav) => res.extend(doc_text_for(db, nav)),
             Approximate(navs) => {
                 let mut msg = String::from("Failed to exactly resolve the symbol. This is probably because rust_analyzer does not yet support glob imports or traits.");
                 if !navs.is_empty() {
@@ -27,7 +24,7 @@ pub(crate) fn hover(
                 }
                 res.push(msg);
                 for nav in navs {
-                    res.extend(doc_text_for(db, nav)?)
+                    res.extend(doc_text_for(db, nav))
                 }
             }
         }
@@ -39,25 +36,24 @@ pub(crate) fn hover(
         let node = find_leaf_at_offset(file.syntax(), position.offset).find_map(|leaf| {
             leaf.ancestors()
                 .find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())
-        });
-        let node = ctry!(node);
+        })?;
         let frange = FileRange {
             file_id: position.file_id,
             range: node.range(),
         };
-        res.extend(type_of(db, frange)?.map(Into::into));
+        res.extend(type_of(db, frange).map(Into::into));
         range = Some(node.range());
     };
 
-    let range = ctry!(range);
+    let range = range?;
     if res.is_empty() {
-        return Ok(None);
+        return None;
     }
     let res = RangeInfo::new(range, res.join("\n\n---\n"));
-    Ok(Some(res))
+    Some(res)
 }
 
-pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Cancelable<Option<String>> {
+pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
     let file = db.source_file(frange.file_id);
     let syntax = file.syntax();
     let leaf_node = find_covering_node(syntax, frange.range);
@@ -67,34 +63,28 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Cancelable<Option
         .take_while(|it| it.range() == leaf_node.range())
         .find(|&it| ast::Expr::cast(it).is_some() || ast::Pat::cast(it).is_some())
         .unwrap_or(leaf_node);
-    let parent_fn = ctry!(node.ancestors().find_map(ast::FnDef::cast));
-    let function = ctry!(hir::source_binder::function_from_source(
-        db,
-        frange.file_id,
-        parent_fn
-    )?);
-    let infer = function.infer(db)?;
-    let syntax_mapping = function.body_syntax_mapping(db)?;
+    let parent_fn = node.ancestors().find_map(ast::FnDef::cast)?;
+    let function = hir::source_binder::function_from_source(db, frange.file_id, parent_fn)?;
+    let infer = function.infer(db);
+    let syntax_mapping = function.body_syntax_mapping(db);
     if let Some(expr) = ast::Expr::cast(node).and_then(|e| syntax_mapping.node_expr(e)) {
-        Ok(Some(infer[expr].to_string()))
+        Some(infer[expr].to_string())
     } else if let Some(pat) = ast::Pat::cast(node).and_then(|p| syntax_mapping.node_pat(p)) {
-        Ok(Some(infer[pat].to_string()))
+        Some(infer[pat].to_string())
     } else {
-        Ok(None)
+        None
     }
 }
 
 // FIXME: this should not really use navigation target. Rather, approximatelly
 // resovled symbol should return a `DefId`.
-fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Cancelable<Option<String>> {
-    let result = match (nav.description(db), nav.docs(db)) {
+fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Option<String> {
+    match (nav.description(db), nav.docs(db)) {
         (Some(desc), Some(docs)) => Some("```rust\n".to_string() + &*desc + "\n```\n\n" + &*docs),
         (Some(desc), None) => Some("```rust\n".to_string() + &*desc + "\n```"),
         (None, Some(docs)) => Some(docs),
         _ => None,
-    };
-
-    Ok(result)
+    }
 }
 
 impl NavigationTarget {
@@ -137,48 +127,29 @@ impl NavigationTarget {
     fn description(&self, db: &RootDatabase) -> Option<String> {
         // TODO: After type inference is done, add type information to improve the output
         let node = self.node(db)?;
-        // TODO: Refactor to be have less repetition
+
+        fn visit_node<T>(node: &T, label: &str) -> Option<String>
+        where
+            T: ast::NameOwner + ast::VisibilityOwner,
+        {
+            let mut string = node
+                .visibility()
+                .map(|v| format!("{} ", v.syntax().text()))
+                .unwrap_or_default();
+            string.push_str(label);
+            node.name()?.syntax().text().push_to(&mut string);
+            Some(string)
+        }
+
         visitor()
-            .visit(|node: &ast::FnDef| {
-                let mut string = "fn ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::StructDef| {
-                let mut string = "struct ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::EnumDef| {
-                let mut string = "enum ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::TraitDef| {
-                let mut string = "trait ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::Module| {
-                let mut string = "mod ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::TypeDef| {
-                let mut string = "type ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::ConstDef| {
-                let mut string = "const ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
-            .visit(|node: &ast::StaticDef| {
-                let mut string = "static ".to_string();
-                node.name()?.syntax().text().push_to(&mut string);
-                Some(string)
-            })
+            .visit(|node: &ast::FnDef| visit_node(node, "fn "))
+            .visit(|node: &ast::StructDef| visit_node(node, "struct "))
+            .visit(|node: &ast::EnumDef| visit_node(node, "enum "))
+            .visit(|node: &ast::TraitDef| visit_node(node, "trait "))
+            .visit(|node: &ast::Module| visit_node(node, "mod "))
+            .visit(|node: &ast::TypeDef| visit_node(node, "type "))
+            .visit(|node: &ast::ConstDef| visit_node(node, "const "))
+            .visit(|node: &ast::StaticDef| visit_node(node, "static "))
             .accept(&node)?
     }
 }
@@ -249,20 +220,19 @@ mod tests {
         assert_eq!("[unknown]", &type_name);
     }
 
-    // FIXME: improve type_of to make this work
     #[test]
     fn test_type_of_for_expr_2() {
         let (analysis, range) = single_file_with_range(
             "
             fn main() {
                 let foo: usize = 1;
-                let bar = <|>1 + foo_test<|>;
+                let bar = <|>1 + foo<|>;
             }
             ",
         );
 
         let type_name = analysis.type_of(range).unwrap().unwrap();
-        assert_eq!("[unknown]", &type_name);
+        assert_eq!("usize", &type_name);
     }
 
 }
diff --git a/crates/ra_ide_api/src/imp.rs b/crates/ra_ide_api/src/imp.rs
index ba4aa0fd5..61771ed40 100644
--- a/crates/ra_ide_api/src/imp.rs
+++ b/crates/ra_ide_api/src/imp.rs
@@ -15,7 +15,6 @@ use ra_syntax::{
 
 use crate::{
     AnalysisChange,
-    Cancelable,
     CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
     Query, RootChange, SourceChange, SourceFileEdit,
     symbol_index::{LibrarySymbolsQuery, FileSymbol},
@@ -99,25 +98,22 @@ impl db::RootDatabase {
 
 impl db::RootDatabase {
     /// Returns `Vec` for the same reason as `parent_module`
-    pub(crate) fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        let module = match source_binder::module_from_file_id(self, file_id)? {
+    pub(crate) fn crate_for(&self, file_id: FileId) -> Vec<CrateId> {
+        let module = match source_binder::module_from_file_id(self, file_id) {
             Some(it) => it,
-            None => return Ok(Vec::new()),
+            None => return Vec::new(),
         };
-        let krate = match module.krate(self)? {
+        let krate = match module.krate(self) {
             Some(it) => it,
-            None => return Ok(Vec::new()),
+            None => return Vec::new(),
         };
-        Ok(vec![krate.crate_id()])
+        vec![krate.crate_id()]
     }
-    pub(crate) fn find_all_refs(
-        &self,
-        position: FilePosition,
-    ) -> Cancelable<Vec<(FileId, TextRange)>> {
+    pub(crate) fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
         let file = self.source_file(position.file_id);
         // Find the binding associated with the offset
-        let (binding, descr) = match find_binding(self, &file, position)? {
-            None => return Ok(Vec::new()),
+        let (binding, descr) = match find_binding(self, &file, position) {
+            None => return Vec::new(),
             Some(it) => it,
         };
 
@@ -128,46 +124,40 @@ impl db::RootDatabase {
             .collect::<Vec<_>>();
         ret.extend(
             descr
-                .scopes(self)?
+                .scopes(self)
                 .find_all_refs(binding)
                 .into_iter()
                 .map(|ref_desc| (position.file_id, ref_desc.range)),
         );
 
-        return Ok(ret);
+        return ret;
 
         fn find_binding<'a>(
             db: &db::RootDatabase,
             source_file: &'a SourceFile,
             position: FilePosition,
-        ) -> Cancelable<Option<(&'a ast::BindPat, hir::Function)>> {
+        ) -> Option<(&'a ast::BindPat, hir::Function)> {
             let syntax = source_file.syntax();
             if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
-                let descr = ctry!(source_binder::function_from_child_node(
+                let descr = source_binder::function_from_child_node(
                     db,
                     position.file_id,
                     binding.syntax(),
-                )?);
-                return Ok(Some((binding, descr)));
+                )?;
+                return Some((binding, descr));
             };
-            let name_ref = ctry!(find_node_at_offset::<ast::NameRef>(syntax, position.offset));
-            let descr = ctry!(source_binder::function_from_child_node(
-                db,
-                position.file_id,
-                name_ref.syntax(),
-            )?);
-            let scope = descr.scopes(db)?;
-            let resolved = ctry!(scope.resolve_local_name(name_ref));
+            let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
+            let descr =
+                source_binder::function_from_child_node(db, position.file_id, name_ref.syntax())?;
+            let scope = descr.scopes(db);
+            let resolved = scope.resolve_local_name(name_ref)?;
             let resolved = resolved.ptr().resolve(source_file);
-            let binding = ctry!(find_node_at_offset::<ast::BindPat>(
-                syntax,
-                resolved.range().end()
-            ));
-            Ok(Some((binding, descr)))
+            let binding = find_node_at_offset::<ast::BindPat>(syntax, resolved.range().end())?;
+            Some((binding, descr))
         }
     }
 
-    pub(crate) fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
+    pub(crate) fn diagnostics(&self, file_id: FileId) -> Vec<Diagnostic> {
         let syntax = self.source_file(file_id);
 
         let mut res = ra_ide_api_light::diagnostics(&syntax)
@@ -179,8 +169,8 @@ impl db::RootDatabase {
                 fix: d.fix.map(|fix| SourceChange::from_local_edit(file_id, fix)),
             })
             .collect::<Vec<_>>();
-        if let Some(m) = source_binder::module_from_file_id(self, file_id)? {
-            for (name_node, problem) in m.problems(self)? {
+        if let Some(m) = source_binder::module_from_file_id(self, file_id) {
+            for (name_node, problem) in m.problems(self) {
                 let source_root = self.file_source_root(file_id);
                 let diag = match problem {
                     Problem::UnresolvedModule { candidate } => {
@@ -228,7 +218,7 @@ impl db::RootDatabase {
                 res.push(diag)
             }
         };
-        Ok(res)
+        res
     }
 
     pub(crate) fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
@@ -239,13 +229,8 @@ impl db::RootDatabase {
             .collect()
     }
 
-    pub(crate) fn rename(
-        &self,
-        position: FilePosition,
-        new_name: &str,
-    ) -> Cancelable<Vec<SourceFileEdit>> {
-        let res = self
-            .find_all_refs(position)?
+    pub(crate) fn rename(&self, position: FilePosition, new_name: &str) -> Vec<SourceFileEdit> {
+        self.find_all_refs(position)
             .iter()
             .map(|(file_id, text_range)| SourceFileEdit {
                 file_id: *file_id,
@@ -255,10 +240,9 @@ impl db::RootDatabase {
                     builder.finish()
                 },
             })
-            .collect::<Vec<_>>();
-        Ok(res)
+            .collect::<Vec<_>>()
     }
-    pub(crate) fn index_resolve(&self, name_ref: &ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
+    pub(crate) fn index_resolve(&self, name_ref: &ast::NameRef) -> Vec<FileSymbol> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
         query.exact();
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index abb50ff95..3a0d2dbbe 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -9,15 +9,6 @@
 //!
 //! The sibling `ra_ide_api_light` handles thouse bits of IDE functionality
 //! which are restricted to a single file and need only syntax.
-macro_rules! ctry {
-    ($expr:expr) => {
-        match $expr {
-            None => return Ok(None),
-            Some(it) => it,
-        }
-    };
-}
-
 mod db;
 mod imp;
 pub mod mock_analysis;
@@ -58,9 +49,11 @@ pub use ra_ide_api_light::{
     LineIndex, LineCol, translate_offset_with_edit,
 };
 pub use ra_db::{
-    Cancelable, Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId
+    Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId
 };
 
+pub type Cancelable<T> = Result<T, Canceled>;
+
 #[derive(Default)]
 pub struct AnalysisChange {
     new_roots: Vec<(SourceRootId, bool)>,
@@ -381,12 +374,11 @@ impl Analysis {
     /// Fuzzy searches for a symbol.
     pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<NavigationTarget>> {
         self.with_db(|db| {
-            let res = symbol_index::world_symbols(db, query)?
+            symbol_index::world_symbols(db, query)
                 .into_iter()
                 .map(NavigationTarget::from_symbol)
-                .collect::<Vec<_>>();
-            Ok(res)
-        })?
+                .collect::<Vec<_>>()
+        })
     }
 
     pub fn goto_definition(
@@ -394,33 +386,33 @@ impl Analysis {
         position: FilePosition,
     ) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
         self.db
-            .catch_canceled(|db| goto_definition::goto_definition(db, position))?
+            .catch_canceled(|db| goto_definition::goto_definition(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))?
+        self.with_db(|db| db.find_all_refs(position))
     }
 
     /// Returns a short text descrbing element at position.
     pub fn hover(&self, position: FilePosition) -> Cancelable<Option<RangeInfo<String>>> {
-        self.with_db(|db| hover::hover(db, position))?
+        self.with_db(|db| hover::hover(db, position))
     }
 
     /// Computes parameter information for the given call expression.
     pub fn call_info(&self, position: FilePosition) -> Cancelable<Option<CallInfo>> {
         self.db
-            .catch_canceled(|db| call_info::call_info(db, position))?
+            .catch_canceled(|db| call_info::call_info(db, position))
     }
 
     /// Returns a `mod name;` declaration which created the current module.
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
-        self.with_db(|db| parent_module::parent_module(db, position))?
+        self.with_db(|db| parent_module::parent_module(db, position))
     }
 
     /// Returns crates this file belongs too.
     pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        self.with_db(|db| db.crate_for(file_id))?
+        self.with_db(|db| db.crate_for(file_id))
     }
 
     /// Returns the root file of the given crate.
@@ -431,20 +423,20 @@ impl Analysis {
     /// Returns the set of possible targets to run for the current file.
     pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
         self.db
-            .catch_canceled(|db| runnables::runnables(db, file_id))?
+            .catch_canceled(|db| runnables::runnables(db, file_id))
     }
 
     /// Computes syntax highlighting for the given file.
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
         self.db
-            .catch_canceled(|db| syntax_highlighting::highlight(db, file_id))?
+            .catch_canceled(|db| syntax_highlighting::highlight(db, file_id))
     }
 
     /// Computes completions at the given position.
     pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
         let completions = self
             .db
-            .catch_canceled(|db| completion::completions(db, position))??;
+            .catch_canceled(|db| completion::completions(db, position))?;
         Ok(completions.map(|it| it.into()))
     }
 
@@ -456,12 +448,12 @@ impl Analysis {
 
     /// Computes the set of diagnostics for the given file.
     pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
-        self.with_db(|db| db.diagnostics(file_id))?
+        self.with_db(|db| db.diagnostics(file_id))
     }
 
     /// Computes the type of the expression at the given position.
     pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
-        self.with_db(|db| hover::type_of(db, frange))?
+        self.with_db(|db| hover::type_of(db, frange))
     }
 
     /// Returns the edit required to rename reference at the position to the new
@@ -471,7 +463,7 @@ impl Analysis {
         position: FilePosition,
         new_name: &str,
     ) -> Cancelable<Vec<SourceFileEdit>> {
-        self.with_db(|db| db.rename(position, new_name))?
+        self.with_db(|db| db.rename(position, new_name))
     }
 
     fn with_db<F: FnOnce(&db::RootDatabase) -> T + std::panic::UnwindSafe, T>(
diff --git a/crates/ra_ide_api/src/navigation_target.rs b/crates/ra_ide_api/src/navigation_target.rs
index 230d0f67a..21c15c0c0 100644
--- a/crates/ra_ide_api/src/navigation_target.rs
+++ b/crates/ra_ide_api/src/navigation_target.rs
@@ -1,4 +1,4 @@
-use ra_db::{FileId, Cancelable};
+use ra_db::FileId;
 use ra_syntax::{
     SyntaxNode, AstNode, SmolStr, TextRange, ast,
     SyntaxKind::{self, NAME},
@@ -69,84 +69,72 @@ impl NavigationTarget {
         }
     }
 
-    pub(crate) fn from_module(
-        db: &RootDatabase,
-        module: hir::Module,
-    ) -> Cancelable<NavigationTarget> {
-        let (file_id, source) = module.definition_source(db)?;
+    pub(crate) fn from_module(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
+        let (file_id, source) = module.definition_source(db);
         let name = module
-            .name(db)?
+            .name(db)
             .map(|it| it.to_string().into())
             .unwrap_or_default();
-        let res = match source {
+        match source {
             ModuleSource::SourceFile(node) => {
                 NavigationTarget::from_syntax(file_id, name, None, node.syntax())
             }
             ModuleSource::Module(node) => {
                 NavigationTarget::from_syntax(file_id, name, None, node.syntax())
             }
-        };
-        Ok(res)
+        }
     }
 
-    pub(crate) fn from_module_to_decl(
-        db: &RootDatabase,
-        module: hir::Module,
-    ) -> Cancelable<NavigationTarget> {
+    pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
         let name = module
-            .name(db)?
+            .name(db)
             .map(|it| it.to_string().into())
             .unwrap_or_default();
-        if let Some((file_id, source)) = module.declaration_source(db)? {
-            return Ok(NavigationTarget::from_syntax(
-                file_id,
-                name,
-                None,
-                source.syntax(),
-            ));
+        if let Some((file_id, source)) = module.declaration_source(db) {
+            return NavigationTarget::from_syntax(file_id, name, None, source.syntax());
         }
         NavigationTarget::from_module(db, module)
     }
 
     // TODO once Def::Item is gone, this should be able to always return a NavigationTarget
-    pub(crate) fn from_def(db: &RootDatabase, def: Def) -> Cancelable<Option<NavigationTarget>> {
+    pub(crate) fn from_def(db: &RootDatabase, def: Def) -> Option<NavigationTarget> {
         let res = match def {
             Def::Struct(s) => {
-                let (file_id, node) = s.source(db)?;
+                let (file_id, node) = s.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Enum(e) => {
-                let (file_id, node) = e.source(db)?;
+                let (file_id, node) = e.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::EnumVariant(ev) => {
-                let (file_id, node) = ev.source(db)?;
+                let (file_id, node) = ev.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Function(f) => {
-                let (file_id, node) = f.source(db)?;
+                let (file_id, node) = f.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Trait(f) => {
-                let (file_id, node) = f.source(db)?;
+                let (file_id, node) = f.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Type(f) => {
-                let (file_id, node) = f.source(db)?;
+                let (file_id, node) = f.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Static(f) => {
-                let (file_id, node) = f.source(db)?;
+                let (file_id, node) = f.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
             Def::Const(f) => {
-                let (file_id, node) = f.source(db)?;
+                let (file_id, node) = f.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
-            Def::Module(m) => NavigationTarget::from_module(db, m)?,
-            Def::Item => return Ok(None),
+            Def::Module(m) => NavigationTarget::from_module(db, m),
+            Def::Item => return None,
         };
-        Ok(Some(res))
+        Some(res)
     }
 
     #[cfg(test)]
diff --git a/crates/ra_ide_api/src/parent_module.rs b/crates/ra_ide_api/src/parent_module.rs
index 675042a6c..e94297fe3 100644
--- a/crates/ra_ide_api/src/parent_module.rs
+++ b/crates/ra_ide_api/src/parent_module.rs
@@ -1,19 +1,16 @@
-use ra_db::{Cancelable, FilePosition};
+use ra_db::FilePosition;
 
 use crate::{NavigationTarget, db::RootDatabase};
 
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
-pub(crate) fn parent_module(
-    db: &RootDatabase,
-    position: FilePosition,
-) -> Cancelable<Vec<NavigationTarget>> {
-    let module = match hir::source_binder::module_from_position(db, position)? {
-        None => return Ok(Vec::new()),
+pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
+    let module = match hir::source_binder::module_from_position(db, position) {
+        None => return Vec::new(),
         Some(it) => it,
     };
-    let nav = NavigationTarget::from_module_to_decl(db, module)?;
-    Ok(vec![nav])
+    let nav = NavigationTarget::from_module_to_decl(db, module);
+    vec![nav]
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 53e49da5b..0f9f8deb3 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
     TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner, ModuleItemOwner},
 };
-use ra_db::{Cancelable, SyntaxDatabase};
+use ra_db::SyntaxDatabase;
 
 use crate::{db::RootDatabase, FileId};
 
@@ -21,14 +21,13 @@ pub enum RunnableKind {
     Bin,
 }
 
-pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Runnable>> {
+pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let source_file = db.source_file(file_id);
-    let res = source_file
+    source_file
         .syntax()
         .descendants()
         .filter_map(|i| runnable(db, file_id, i))
-        .collect();
-    Ok(res)
+        .collect()
 }
 
 fn runnable(db: &RootDatabase, file_id: FileId, item: &SyntaxNode) -> Option<Runnable> {
@@ -75,20 +74,114 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: &ast::Module) -> Opt
         return None;
     }
     let range = module.syntax().range();
-    let module =
-        hir::source_binder::module_from_child_node(db, file_id, module.syntax()).ok()??;
+    let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax())?;
 
     // FIXME: thread cancellation instead of `.ok`ing
     let path = module
         .path_to_root(db)
-        .ok()?
         .into_iter()
         .rev()
-        .filter_map(|it| it.name(db).ok())
-        .filter_map(|it| it)
+        .filter_map(|it| it.name(db))
         .join("::");
     Some(Runnable {
         range,
         kind: RunnableKind::TestMod { path },
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use insta::assert_debug_snapshot_matches;
+
+    use crate::mock_analysis::analysis_and_position;
+
+    #[test]
+    fn test_runnables() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+
+        #[test]
+        fn test_foo() {}
+
+        #[test]
+        #[ignore]
+        fn test_foo() {}
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot_matches!("runnables", &runnables)
+    }
+
+    #[test]
+    fn test_runnables_module() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        mod test_mod {
+            #[test]
+            fn test_foo1() {}
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot_matches!("runnables_module", &runnables)
+    }
+
+    #[test]
+    fn test_runnables_one_depth_layer_module() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        mod foo {
+            mod test_mod {
+                #[test]
+                fn test_foo1() {}
+            }
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot_matches!("runnables_one_depth_layer_module", &runnables)
+    }
+
+    #[test]
+    fn test_runnables_multiple_depth_module() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        mod foo {
+            mod bar {
+                mod test_mod {
+                    #[test]
+                    fn test_foo1() {}
+                }
+            }
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot_matches!("runnables_multiple_depth_module", &runnables)
+    }
+
+    #[test]
+    fn test_runnables_no_test_function_in_module() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        mod test_mod {
+            fn foo1() {}
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert!(runnables.is_empty())
+    }
+
+}
diff --git a/crates/ra_ide_api/src/snapshots/tests__highlight_query_group_macro.snap b/crates/ra_ide_api/src/snapshots/tests__highlight_query_group_macro.snap
new file mode 100644
index 000000000..b84aa9c78
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__highlight_query_group_macro.snap
@@ -0,0 +1,26 @@
+Created: 2019-01-15T11:15:20.732493641+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/syntax_highlighting.rs
+
+[
+    HighlightedRange {
+        range: [20; 32),
+        tag: "macro"
+    },
+    HighlightedRange {
+        range: [13; 18),
+        tag: "text"
+    },
+    HighlightedRange {
+        range: [51; 54),
+        tag: "keyword"
+    },
+    HighlightedRange {
+        range: [55; 60),
+        tag: "keyword"
+    },
+    HighlightedRange {
+        range: [61; 72),
+        tag: "function"
+    }
+]
diff --git a/crates/ra_ide_api/src/snapshots/tests__highlights_code_inside_macros.snap b/crates/ra_ide_api/src/snapshots/tests__highlights_code_inside_macros.snap
new file mode 100644
index 000000000..14c6e5a4e
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__highlights_code_inside_macros.snap
@@ -0,0 +1,70 @@
+Created: 2019-01-15T11:15:20.732523231+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/syntax_highlighting.rs
+
+[
+    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: [82; 86),
+        tag: "macro"
+    },
+    HighlightedRange {
+        range: [89; 92),
+        tag: "keyword"
+    },
+    HighlightedRange {
+        range: [97; 99),
+        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"
+    },
+    HighlightedRange {
+        range: [89; 92),
+        tag: "keyword"
+    },
+    HighlightedRange {
+        range: [93; 94),
+        tag: "function"
+    },
+    HighlightedRange {
+        range: [97; 99),
+        tag: "literal"
+    },
+    HighlightedRange {
+        range: [101; 102),
+        tag: "text"
+    }
+]
diff --git a/crates/ra_ide_api/src/snapshots/tests__runnables.snap b/crates/ra_ide_api/src/snapshots/tests__runnables.snap
new file mode 100644
index 000000000..ba6cba0ab
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__runnables.snap
@@ -0,0 +1,22 @@
+Created: 2019-01-15T11:15:20.732460119+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/runnables.rs
+
+[
+    Runnable {
+        range: [1; 21),
+        kind: Bin
+    },
+    Runnable {
+        range: [22; 46),
+        kind: Test {
+            name: "test_foo"
+        }
+    },
+    Runnable {
+        range: [47; 81),
+        kind: Test {
+            name: "test_foo"
+        }
+    }
+]
diff --git a/crates/ra_ide_api/src/snapshots/tests__runnables_module.snap b/crates/ra_ide_api/src/snapshots/tests__runnables_module.snap
new file mode 100644
index 000000000..b3f2d4d6e
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__runnables_module.snap
@@ -0,0 +1,18 @@
+Created: 2019-01-15T11:15:20.732460109+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/runnables.rs
+
+[
+    Runnable {
+        range: [1; 59),
+        kind: TestMod {
+            path: "test_mod"
+        }
+    },
+    Runnable {
+        range: [28; 57),
+        kind: Test {
+            name: "test_foo1"
+        }
+    }
+]
diff --git a/crates/ra_ide_api/src/snapshots/tests__runnables_multiple_depth_module.snap b/crates/ra_ide_api/src/snapshots/tests__runnables_multiple_depth_module.snap
new file mode 100644
index 000000000..6eba482e7
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__runnables_multiple_depth_module.snap
@@ -0,0 +1,18 @@
+Created: 2019-01-15T11:15:20.732522773+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/runnables.rs
+
+[
+    Runnable {
+        range: [41; 115),
+        kind: TestMod {
+            path: "foo::bar::test_mod"
+        }
+    },
+    Runnable {
+        range: [68; 105),
+        kind: Test {
+            name: "test_foo1"
+        }
+    }
+]
diff --git a/crates/ra_ide_api/src/snapshots/tests__runnables_one_depth_layer_module.snap b/crates/ra_ide_api/src/snapshots/tests__runnables_one_depth_layer_module.snap
new file mode 100644
index 000000000..f40c762f3
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/tests__runnables_one_depth_layer_module.snap
@@ -0,0 +1,18 @@
+Created: 2019-01-15T11:15:20.732480089+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/src/runnables.rs
+
+[
+    Runnable {
+        range: [23; 85),
+        kind: TestMod {
+            path: "foo::test_mod"
+        }
+    },
+    Runnable {
+        range: [46; 79),
+        kind: Test {
+            name: "test_foo1"
+        }
+    }
+]
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
index fdda57022..74165d68f 100644
--- a/crates/ra_ide_api/src/symbol_index.rs
+++ b/crates/ra_ide_api/src/symbol_index.rs
@@ -37,13 +37,13 @@ use salsa::ParallelDatabase;
 use rayon::prelude::*;
 
 use crate::{
-    Cancelable, FileId, Query,
+    FileId, Query,
     db::RootDatabase,
 };
 
 salsa::query_group! {
     pub(crate) trait SymbolsDatabase: hir::db::HirDatabase {
-        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+        fn file_symbols(file_id: FileId) -> Arc<SymbolIndex> {
             type FileSymbolsQuery;
         }
         fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
@@ -53,8 +53,8 @@ salsa::query_group! {
     }
 }
 
-fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
-    db.check_canceled()?;
+fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex> {
+    db.check_canceled();
     let source_file = db.source_file(file_id);
     let mut symbols = source_file
         .syntax()
@@ -63,16 +63,16 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Cancelable<Arc<Sy
         .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
         .collect::<Vec<_>>();
 
-    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id)? {
+    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id) {
         let node = find_covering_node(source_file.syntax(), text_range);
         let ptr = LocalSyntaxPtr::new(node);
         symbols.push(FileSymbol { file_id, name, ptr })
     }
 
-    Ok(Arc::new(SymbolIndex::new(symbols)))
+    Arc::new(SymbolIndex::new(symbols))
 }
 
-pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Cancelable<Vec<FileSymbol>> {
+pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
     /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
     struct Snap(salsa::Snapshot<RootDatabase>);
     impl Clone for Snap {
@@ -98,10 +98,9 @@ pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Cancelable<Vec<F
         files
             .par_iter()
             .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
-            .filter_map(|it| it.ok())
             .collect()
     };
-    Ok(query.search(&buf))
+    query.search(&buf)
 }
 
 #[derive(Default, Debug)]
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index cb19e9515..a4d3ad005 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -2,11 +2,11 @@ use ra_syntax::{ast, AstNode,};
 use ra_db::SyntaxDatabase;
 
 use crate::{
-    FileId, Cancelable, HighlightedRange,
+    FileId, HighlightedRange,
     db::RootDatabase,
 };
 
-pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
+pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
     let source_file = db.source_file(file_id);
     let mut res = ra_ide_api_light::highlight(source_file.syntax());
     for macro_call in source_file
@@ -28,13 +28,14 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Hi
             res.extend(mapped_ranges);
         }
     }
-    Ok(res)
+    res
 }
 
 #[cfg(test)]
 mod tests {
     use crate::mock_analysis::single_file;
-    use test_utils::assert_eq_dbg;
+
+    use insta::assert_debug_snapshot_matches;
 
     #[test]
     fn highlights_code_inside_macros() {
@@ -47,25 +48,7 @@ mod tests {
             ",
         );
         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: [82; 86), tag: "macro" },
-                HighlightedRange { range: [89; 92), tag: "keyword" },
-                HighlightedRange { range: [97; 99), 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" },
-                HighlightedRange { range: [89; 92), tag: "keyword" },
-                HighlightedRange { range: [93; 94), tag: "function" },
-                HighlightedRange { range: [97; 99), tag: "literal" },
-                HighlightedRange { range: [101; 102), tag: "text" }]"#,
-            &highlights,
-        )
+        assert_debug_snapshot_matches!("highlights_code_inside_macros", &highlights);
     }
 
     // FIXME: this test is not really necessary: artifact of the inital hacky
@@ -80,13 +63,6 @@ mod tests {
             ",
         );
         let highlights = analysis.highlight(file_id).unwrap();
-        assert_eq_dbg(
-            r#"[HighlightedRange { range: [20; 32), tag: "macro" },
-                HighlightedRange { range: [13; 18), tag: "text" },
-                HighlightedRange { range: [51; 54), tag: "keyword" },
-                HighlightedRange { range: [55; 60), tag: "keyword" },
-                HighlightedRange { range: [61; 72), tag: "function" }]"#,
-            &highlights,
-        )
+        assert_debug_snapshot_matches!("highlight_query_group_macro", &highlights);
     }
 }
diff --git a/crates/ra_ide_api/tests/test/main.rs b/crates/ra_ide_api/tests/test/main.rs
index 7dc1dba73..2b863aedf 100644
--- a/crates/ra_ide_api/tests/test/main.rs
+++ b/crates/ra_ide_api/tests/test/main.rs
@@ -1,7 +1,6 @@
-mod runnables;
-
 use ra_syntax::TextRange;
-use test_utils::{assert_eq_dbg, assert_eq_text};
+use test_utils::assert_eq_text;
+use insta::assert_debug_snapshot_matches;
 
 use ra_ide_api::{
     mock_analysis::{single_file, single_file_with_position, MockAnalysis},
@@ -12,18 +11,7 @@ use ra_ide_api::{
 fn test_unresolved_module_diagnostic() {
     let (analysis, file_id) = single_file("mod foo;");
     let diagnostics = analysis.diagnostics(file_id).unwrap();
-    assert_eq_dbg(
-        r#"[Diagnostic {
-            message: "unresolved module",
-            range: [4; 7),
-            fix: Some(SourceChange {
-                label: "create module",
-                source_file_edits: [],
-                file_system_edits: [CreateFile { source_root: SourceRootId(0), path: "foo.rs" }],
-                cursor_position: None }),
-                severity: Error }]"#,
-        &diagnostics,
-    );
+    assert_debug_snapshot_matches!("unresolved_module_diagnostic", &diagnostics);
 }
 
 // FIXME: move this test to hir
@@ -31,7 +19,7 @@ fn test_unresolved_module_diagnostic() {
 fn test_unresolved_module_diagnostic_no_diag_for_inline_mode() {
     let (analysis, file_id) = single_file("mod foo {}");
     let diagnostics = analysis.diagnostics(file_id).unwrap();
-    assert_eq_dbg(r#"[]"#, &diagnostics);
+    assert!(diagnostics.is_empty());
 }
 
 #[test]
diff --git a/crates/ra_ide_api/tests/test/runnables.rs b/crates/ra_ide_api/tests/test/runnables.rs
deleted file mode 100644
index da8d5e0d5..000000000
--- a/crates/ra_ide_api/tests/test/runnables.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-use test_utils::assert_eq_dbg;
-
-use ra_ide_api::mock_analysis::analysis_and_position;
-
-#[test]
-fn test_runnables() {
-    let (analysis, pos) = analysis_and_position(
-        r#"
-        //- /lib.rs
-        <|> //empty
-        fn main() {}
-
-        #[test]
-        fn test_foo() {}
-
-        #[test]
-        #[ignore]
-        fn test_foo() {}
-        "#,
-    );
-    let runnables = analysis.runnables(pos.file_id).unwrap();
-    assert_eq_dbg(
-        r#"[Runnable { range: [1; 21), kind: Bin },
-                Runnable { range: [22; 46), kind: Test { name: "test_foo" } },
-                Runnable { range: [47; 81), kind: Test { name: "test_foo" } }]"#,
-        &runnables,
-    )
-}
-
-#[test]
-fn test_runnables_module() {
-    let (analysis, pos) = analysis_and_position(
-        r#"
-        //- /lib.rs
-        <|> //empty
-        mod test_mod {
-            #[test]
-            fn test_foo1() {}
-        }
-        "#,
-    );
-    let runnables = analysis.runnables(pos.file_id).unwrap();
-    assert_eq_dbg(
-        r#"[Runnable { range: [1; 59), kind: TestMod { path: "test_mod" } },
-                Runnable { range: [28; 57), kind: Test { name: "test_foo1" } }]"#,
-        &runnables,
-    )
-}
-
-#[test]
-fn test_runnables_one_depth_layer_module() {
-    let (analysis, pos) = analysis_and_position(
-        r#"
-        //- /lib.rs
-        <|> //empty
-        mod foo {
-            mod test_mod {
-                #[test]
-                fn test_foo1() {}
-            }
-        }
-        "#,
-    );
-    let runnables = analysis.runnables(pos.file_id).unwrap();
-    assert_eq_dbg(
-        r#"[Runnable { range: [23; 85), kind: TestMod { path: "foo::test_mod" } },
-                Runnable { range: [46; 79), kind: Test { name: "test_foo1" } }]"#,
-        &runnables,
-    )
-}
-
-#[test]
-fn test_runnables_multiple_depth_module() {
-    let (analysis, pos) = analysis_and_position(
-        r#"
-        //- /lib.rs
-        <|> //empty
-        mod foo {
-            mod bar {
-                mod test_mod {
-                    #[test]
-                    fn test_foo1() {}
-                }
-            }
-        }
-        "#,
-    );
-    let runnables = analysis.runnables(pos.file_id).unwrap();
-    assert_eq_dbg(
-        r#"[Runnable { range: [41; 115), kind: TestMod { path: "foo::bar::test_mod" } },
-                Runnable { range: [68; 105), kind: Test { name: "test_foo1" } }]"#,
-        &runnables,
-    )
-}
-
-#[test]
-fn test_runnables_no_test_function_in_module() {
-    let (analysis, pos) = analysis_and_position(
-        r#"
-        //- /lib.rs
-        <|> //empty
-        mod test_mod {
-            fn foo1() {}
-        }
-        "#,
-    );
-    let runnables = analysis.runnables(pos.file_id).unwrap();
-    assert_eq_dbg(r#"[]"#, &runnables)
-}
diff --git a/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap b/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
new file mode 100644
index 000000000..1b41e2b00
--- /dev/null
+++ b/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
@@ -0,0 +1,26 @@
+Created: 2019-01-15T11:15:20.891129945+00:00
+Creator: [email protected]
+Source: crates/ra_ide_api/tests/test/main.rs
+
+[
+    Diagnostic {
+        message: "unresolved module",
+        range: [4; 7),
+        fix: Some(
+            SourceChange {
+                label: "create module",
+                source_file_edits: [],
+                file_system_edits: [
+                    CreateFile {
+                        source_root: SourceRootId(
+                            0
+                        ),
+                        path: "foo.rs"
+                    }
+                ],
+                cursor_position: None
+            }
+        ),
+        severity: Error
+    }
+]