3 files changed, 61 insertions, 74 deletions
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index 8d6b7fc19..66d7e1713 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -2,7 +2,6 @@ mod scope;
 use std::sync::Arc;
-use ra_db::Cancelable;
 use ra_syntax::{TreeArc, ast::{self, NameOwner}};
 use crate::{
@@ -20,16 +19,16 @@ impl Function {
        Function { def_id }
    }
-    pub(crate) fn body(&self, db: &impl HirDatabase) -> Cancelable<Arc<Body>> {
+    pub(crate) fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
        db.body_hir(self.def_id)
    }
-    pub(crate) fn module(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub(crate) fn module(&self, db: &impl HirDatabase) -> Module {
        self.def_id.module(db)
    }
    /// The containing impl block, if this is a method.
-    pub(crate) fn impl_block(&self, db: &impl HirDatabase) -> Cancelable<Option<ImplBlock>> {
+    pub(crate) fn impl_block(&self, db: &impl HirDatabase) -> Option<ImplBlock> {
        self.def_id.impl_block(db)
    }
 }
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index 3275eafed..8c6e34873 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -1,4 +1,4 @@
-use ra_db::{CrateId, Cancelable};
+use ra_db::CrateId;
 use crate::{
    HirFileId, Crate, CrateDependency, AsName, DefLoc, DefKind, Module, SourceItemId,
@@ -20,18 +20,18 @@ impl Crate {
            })
            .collect()
    }
-    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Option<Module> {
        let crate_graph = db.crate_graph();
        let file_id = crate_graph.crate_root(self.crate_id);
        let source_root_id = db.file_source_root(file_id);
        let file_id = HirFileId::from(file_id);
-        let module_tree = db.module_tree(source_root_id)?;
+        let module_tree = db.module_tree(source_root_id);
        // FIXME: teach module tree about crate roots instead of guessing
        let source = SourceItemId {
            file_id,
            item_id: None,
        };
-        let module_id = ctry!(module_tree.find_module_by_source(source));
+        let module_id = module_tree.find_module_by_source(source)?;
        let def_loc = DefLoc {
            kind: DefKind::Module,
@@ -42,6 +42,6 @@ impl Crate {
        let def_id = def_loc.id(db);
        let module = Module::new(def_id);
-        Ok(Some(module))
+        Some(module)
    }
 }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 775dd6709..a5c032d69 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -1,4 +1,4 @@
-use ra_db::{Cancelable, SourceRootId, FileId};
+use ra_db::{SourceRootId, FileId};
 use ra_syntax::{ast, SyntaxNode, AstNode, TreeArc};
 use crate::{
@@ -18,8 +18,8 @@ impl Module {
        db: &impl HirDatabase,
        source_root_id: SourceRootId,
        module_id: ModuleId,
-    ) -> Cancelable<Self> {
+    ) -> Self {
-        let module_tree = db.module_tree(source_root_id)?;
+        let module_tree = db.module_tree(source_root_id);
        let def_loc = DefLoc {
            kind: DefKind::Module,
            source_root_id,
@@ -27,21 +27,17 @@ impl Module {
            source_item_id: module_id.source(&module_tree),
        };
        let def_id = def_loc.id(db);
-        let module = Module::new(def_id);
+        Module::new(def_id)
-        Ok(module)
    }
-    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
+    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Option<Name> {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
-        let link = ctry!(loc.module_id.parent_link(&module_tree));
+        let link = loc.module_id.parent_link(&module_tree)?;
-        Ok(Some(link.name(&module_tree).clone()))
+        Some(link.name(&module_tree).clone())
    }
-    pub fn definition_source_impl(
+    pub fn definition_source_impl(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(FileId, ModuleSource)> {
        let loc = self.def_id.loc(db);
        let file_id = loc.source_item_id.file_id.as_original_file();
        let syntax_node = db.file_item(loc.source_item_id);
@@ -51,94 +47,89 @@ impl Module {
            let module = ast::Module::cast(&syntax_node).unwrap();
            ModuleSource::Module(module.to_owned())
        };
-        Ok((file_id, module_source))
+        (file_id, module_source)
    }
    pub fn declaration_source_impl(
        &self,
        db: &impl HirDatabase,
-    ) -> Cancelable<Option<(FileId, TreeArc<ast::Module>)>> {
+    ) -> Option<(FileId, TreeArc<ast::Module>)> {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
-        let link = ctry!(loc.module_id.parent_link(&module_tree));
+        let link = loc.module_id.parent_link(&module_tree)?;
        let file_id = link
            .owner(&module_tree)
            .source(&module_tree)
            .file_id
            .as_original_file();
        let src = link.source(&module_tree, db);
-        Ok(Some((file_id, src)))
+        Some((file_id, src))
    }
-    pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
+    pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Option<Crate> {
-        let root = self.crate_root(db)?;
+        let root = self.crate_root(db);
        let loc = root.def_id.loc(db);
        let file_id = loc.source_item_id.file_id.as_original_file();
        let crate_graph = db.crate_graph();
-        let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id));
+        let crate_id = crate_graph.crate_id_for_crate_root(file_id)?;
-        Ok(Some(Crate::new(crate_id)))
+        Some(Crate::new(crate_id))
    }
-    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable<Module> {
+    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Module {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
        let module_id = loc.module_id.crate_root(&module_tree);
        Module::from_module_id(db, loc.source_root_id, module_id)
    }
    /// Finds a child module with the specified name.
-    pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable<Option<Module>> {
+    pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
-        let child_id = ctry!(loc.module_id.child(&module_tree, name));
+        let child_id = loc.module_id.child(&module_tree, name)?;
-        Module::from_module_id(db, loc.source_root_id, child_id).map(Some)
+        Some(Module::from_module_id(db, loc.source_root_id, child_id))
    }
    /// Iterates over all child modules.
-    pub fn children_impl(&self, db: &impl HirDatabase) -> Cancelable<impl Iterator<Item = Module>> {
+    pub fn children_impl(&self, db: &impl HirDatabase) -> impl Iterator<Item = Module> {
        // FIXME this should be implementable without collecting into a vec, but
        // it's kind of hard since the iterator needs to keep a reference to the
        // module tree.
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
        let children = loc
            .module_id
            .children(&module_tree)
            .map(|(_, module_id)| Module::from_module_id(db, loc.source_root_id, module_id))
-            .collect::<Cancelable<Vec<_>>>()?;
+            .collect::<Vec<_>>();
-        Ok(children.into_iter())
+        children.into_iter()
    }
-    pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable<Option<Module>> {
+    pub fn parent_impl(&self, db: &impl HirDatabase) -> Option<Module> {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
-        let parent_id = ctry!(loc.module_id.parent(&module_tree));
+        let parent_id = loc.module_id.parent(&module_tree)?;
-        Module::from_module_id(db, loc.source_root_id, parent_id).map(Some)
+        Some(Module::from_module_id(db, loc.source_root_id, parent_id))
    }
    /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
+    pub fn scope_impl(&self, db: &impl HirDatabase) -> ModuleScope {
        let loc = self.def_id.loc(db);
-        let item_map = db.item_map(loc.source_root_id)?;
+        let item_map = db.item_map(loc.source_root_id);
-        let res = item_map.per_module[&loc.module_id].clone();
+        item_map.per_module[&loc.module_id].clone()
-        Ok(res)
    }
-    pub fn resolve_path_impl(
+    pub fn resolve_path_impl(&self, db: &impl HirDatabase, path: &Path) -> PerNs<DefId> {
-        &self,
-        db: &impl HirDatabase,
-        path: &Path,
-    ) -> Cancelable<PerNs<DefId>> {
        let mut curr_per_ns = PerNs::types(
            match path.kind {
-                PathKind::Crate => self.crate_root(db)?,
+                PathKind::Crate => self.crate_root(db),
                PathKind::Self_ | PathKind::Plain => self.clone(),
                PathKind::Super => {
-                    if let Some(p) = self.parent(db)? {
+                    if let Some(p) = self.parent(db) {
                        p
                    } else {
-                        return Ok(PerNs::none());
+                        return PerNs::none();
                    }
                }
            }
@@ -150,47 +141,44 @@ impl Module {
            let curr = if let Some(r) = curr_per_ns.as_ref().take_types() {
                r
            } else {
-                return Ok(PerNs::none());
+                return PerNs::none();
            };
-            let module = match curr.resolve(db)? {
+            let module = match curr.resolve(db) {
                Def::Module(it) => it,
                Def::Enum(e) => {
                    if segments.len() == idx + 1 {
                        // enum variant
                        let matching_variant =
-                            e.variants(db)?.into_iter().find(|(n, _variant)| n == name);
+                            e.variants(db).into_iter().find(|(n, _variant)| n == name);
                        if let Some((_n, variant)) = matching_variant {
-                            return Ok(PerNs::both(variant.def_id(), e.def_id()));
+                            return PerNs::both(variant.def_id(), e.def_id());
                        } else {
-                            return Ok(PerNs::none());
+                            return PerNs::none();
                        }
                    } else if segments.len() == idx {
                        // enum
-                        return Ok(PerNs::types(e.def_id()));
+                        return PerNs::types(e.def_id());
                    } else {
                        // malformed enum?
-                        return Ok(PerNs::none());
+                        return PerNs::none();
                    }
                }
-                _ => return Ok(PerNs::none()),
+                _ => return PerNs::none(),
            };
-            let scope = module.scope(db)?;
+            let scope = module.scope(db);
            curr_per_ns = if let Some(r) = scope.get(&name) {
                r.def_id
            } else {
-                return Ok(PerNs::none());
+                return PerNs::none();
            };
        }
-        Ok(curr_per_ns)
+        curr_per_ns
    }
-    pub fn problems_impl(
+    pub fn problems_impl(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<Vec<(TreeArc<SyntaxNode>, Problem)>> {
        let loc = self.def_id.loc(db);
-        let module_tree = db.module_tree(loc.source_root_id)?;
+        let module_tree = db.module_tree(loc.source_root_id);
-        Ok(loc.module_id.problems(&module_tree, db))
+        loc.module_id.problems(&module_tree, db)
    }
 }