Merge #557

557: remove Canceled from impl of ra_ide_api r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

12 files changed, 114 insertions, 169 deletions

diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index efa320d83..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 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 cb86ba9a3..473edc50e 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -1,29 +1,27 @@
 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 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, .. } => {
@@ -35,7 +33,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty)
                                 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 42468681a..1eded7658 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -1,16 +1,15 @@
 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() {
         Some(it) => it,
-        None => return Ok(()),
+        None => return,
     };
     match def_id.resolve(ctx.db) {
         hir::Def::Module(module) => {
@@ -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 660c7d16e..699680748 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -1,18 +1,15 @@
 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);
@@ -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 f5b5ed689..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>>> {
+    ) -> 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());
+        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/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index cdd8e211d..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,7 +42,7 @@ 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())
@@ -54,7 +51,7 @@ pub(crate) fn reference_definition(
         // 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,7 +60,7 @@ pub(crate) fn reference_definition(
             .parent()
             .and_then(ast::MethodCallExpr::cast)
         {
-            let infer_result = function.infer(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
@@ -71,7 +68,7 @@ pub(crate) fn reference_definition(
                 .and_then(|it| infer_result.method_resolution(it))
             {
                 if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)) {
-                    return Ok(Exact(target));
+                    return Exact(target);
                 }
             };
         }
@@ -88,7 +85,7 @@ pub(crate) fn reference_definition(
             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));
+                    return Exact(target);
                 }
             }
         }
@@ -99,25 +96,25 @@ pub(crate) fn reference_definition(
         .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)
             {
                 let nav = NavigationTarget::from_module(db, child_module);
-                return Ok(Some(vec![nav]));
+                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 0e9c48421..d91151c15 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -1,4 +1,4 @@
-use ra_db::{Cancelable, SyntaxDatabase};
+use ra_db::{SyntaxDatabase};
 use ra_syntax::{
     AstNode, SyntaxNode, TreeArc,
     ast::self,
@@ -7,19 +7,16 @@ use ra_syntax::{
 
 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 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 {
diff --git a/crates/ra_ide_api/src/imp.rs b/crates/ra_ide_api/src/imp.rs
index 8b2cd6e27..a21cae624 100644
--- a/crates/ra_ide_api/src/imp.rs
+++ b/crates/ra_ide_api/src/imp.rs
@@ -110,14 +110,11 @@ impl db::RootDatabase {
         };
         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,
         };
 
@@ -134,36 +131,30 @@ impl db::RootDatabase {
                 .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 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 = ctry!(scope.resolve_local_name(name_ref));
+            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))
         }
     }
 
@@ -180,7 +171,7 @@ impl db::RootDatabase {
             })
             .collect::<Vec<_>>();
         if let Some(m) = source_binder::module_from_file_id(self, file_id) {
-            for (name_node, problem) in m.problems(self)? {
+            for (name_node, problem) in m.problems(self) {
                 let source_root = self.file_source_root(file_id);
                 let diag = match problem {
                     Problem::UnresolvedModule { candidate } => {
@@ -239,13 +230,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,8 +241,7 @@ impl db::RootDatabase {
                     builder.finish()
                 },
             })
-            .collect::<Vec<_>>();
-        Ok(res)
+            .collect::<Vec<_>>()
     }
     pub(crate) fn index_resolve(&self, name_ref: &ast::NameRef) -> Vec<FileSymbol> {
         let name = name_ref.text();
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 0f690fc84..ea5267ad9 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)>,
@@ -393,28 +386,28 @@ 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.
@@ -430,7 +423,7 @@ 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.
@@ -443,7 +436,7 @@ impl Analysis {
     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()))
     }
 
@@ -460,7 +453,7 @@ impl Analysis {
 
     /// 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
@@ -470,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/parent_module.rs b/crates/ra_ide_api/src/parent_module.rs
index 379b3f3a4..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>> {
+pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
     let module = match hir::source_binder::module_from_position(db, position) {
-        None => return Ok(Vec::new()),
+        None => return Vec::new(),
         Some(it) => it,
     };
     let nav = NavigationTarget::from_module_to_decl(db, module);
-    Ok(vec![nav])
+    vec![nav]
 }
 
 #[cfg(test)]
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index a3207fdd2..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> {