7 files changed, 55 insertions, 76 deletions

diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index bcb705c24..57d112f74 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -19,7 +19,7 @@ impl Struct {
     }
 
     pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Cancelable<Arc<VariantData>> {
-        Ok(db.struct_data(self.def_id)?.variant_data.clone())
+        Ok(db.struct_data(self.def_id).variant_data.clone())
     }
 }
 
@@ -37,16 +37,13 @@ impl StructData {
         StructData { name, variant_data }
     }
 
-    pub(crate) fn struct_data_query(
-        db: &impl HirDatabase,
-        def_id: DefId,
-    ) -> Cancelable<Arc<StructData>> {
+    pub(crate) fn struct_data_query(db: &impl HirDatabase, def_id: DefId) -> Arc<StructData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::Struct);
         let syntax = db.file_item(def_loc.source_item_id);
         let struct_def =
             ast::StructDef::cast(&syntax).expect("struct def should point to StructDef node");
-        Ok(Arc::new(StructData::new(struct_def)))
+        Arc::new(StructData::new(struct_def))
     }
 }
 
@@ -84,10 +81,7 @@ impl EnumData {
         EnumData { name, variants }
     }
 
-    pub(crate) fn enum_data_query(
-        db: &impl HirDatabase,
-        def_id: DefId,
-    ) -> Cancelable<Arc<EnumData>> {
+    pub(crate) fn enum_data_query(db: &impl HirDatabase, def_id: DefId) -> Arc<EnumData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::Enum);
         let syntax = db.file_item(def_loc.source_item_id);
@@ -107,7 +101,7 @@ impl EnumData {
         } else {
             Vec::new()
         };
-        Ok(Arc::new(EnumData::new(enum_def, variants)))
+        Arc::new(EnumData::new(enum_def, variants))
     }
 }
 
@@ -133,7 +127,7 @@ impl EnumVariantData {
     pub(crate) fn enum_variant_data_query(
         db: &impl HirDatabase,
         def_id: DefId,
-    ) -> Cancelable<Arc<EnumVariantData>> {
+    ) -> Arc<EnumVariantData> {
         let def_loc = def_id.loc(db);
         assert!(def_loc.kind == DefKind::EnumVariant);
         let syntax = db.file_item(def_loc.source_item_id);
@@ -146,10 +140,7 @@ impl EnumVariantData {
             .expect("enum variant list should have enum ancestor");
         let enum_def_id = get_def_id(db, &def_loc, enum_node, DefKind::Enum);
 
-        Ok(Arc::new(EnumVariantData::new(
-            variant_def,
-            Enum::new(enum_def_id),
-        )))
+        Arc::new(EnumVariantData::new(variant_def, Enum::new(enum_def_id)))
     }
 }
 
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index db270b871..f28e077c6 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -175,13 +175,12 @@ impl Struct {
         self.def_id
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.struct_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.struct_data(self.def_id).name.clone()
     }
 
-    pub fn fields(&self, db: &impl HirDatabase) -> Cancelable<Vec<StructField>> {
-        let res = db
-            .struct_data(self.def_id)?
+    pub fn fields(&self, db: &impl HirDatabase) -> Vec<StructField> {
+        db.struct_data(self.def_id)
             .variant_data
             .fields()
             .iter()
@@ -189,15 +188,11 @@ impl Struct {
                 struct_: self.clone(),
                 name: it.name.clone(),
             })
-            .collect();
-        Ok(res)
+            .collect()
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::StructDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -215,16 +210,16 @@ impl Enum {
         self.def_id
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.enum_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.enum_data(self.def_id).name.clone()
     }
 
-    pub fn variants(&self, db: &impl HirDatabase) -> Cancelable<Vec<(Name, EnumVariant)>> {
-        Ok(db.enum_data(self.def_id)?.variants.clone())
+    pub fn variants(&self, db: &impl HirDatabase) -> Vec<(Name, EnumVariant)> {
+        db.enum_data(self.def_id).variants.clone()
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::EnumDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -242,23 +237,20 @@ impl EnumVariant {
         self.def_id
     }
 
-    pub fn parent_enum(&self, db: &impl HirDatabase) -> Cancelable<Enum> {
-        Ok(db.enum_variant_data(self.def_id)?.parent_enum.clone())
+    pub fn parent_enum(&self, db: &impl HirDatabase) -> Enum {
+        db.enum_variant_data(self.def_id).parent_enum.clone()
     }
 
-    pub fn name(&self, db: &impl HirDatabase) -> Cancelable<Option<Name>> {
-        Ok(db.enum_variant_data(self.def_id)?.name.clone())
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.enum_variant_data(self.def_id).name.clone()
     }
 
-    pub fn variant_data(&self, db: &impl HirDatabase) -> Cancelable<Arc<VariantData>> {
-        Ok(db.enum_variant_data(self.def_id)?.variant_data.clone())
+    pub fn variant_data(&self, db: &impl HirDatabase) -> Arc<VariantData> {
+        db.enum_variant_data(self.def_id).variant_data.clone()
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::EnumVariant>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::EnumVariant>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -305,8 +297,8 @@ impl Function {
         self.def_id
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::FnDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 
     pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Cancelable<Arc<BodySyntaxMapping>> {
@@ -341,8 +333,8 @@ impl Const {
         Const { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::ConstDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::ConstDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -356,11 +348,8 @@ impl Static {
         Static { def_id }
     }
 
-    pub fn source(
-        &self,
-        db: &impl HirDatabase,
-    ) -> Cancelable<(HirFileId, TreeArc<ast::StaticDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -374,8 +363,8 @@ impl Trait {
         Trait { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::TraitDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TraitDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
 
@@ -389,7 +378,7 @@ impl Type {
         Type { def_id }
     }
 
-    pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(HirFileId, TreeArc<ast::TypeDef>)> {
-        Ok(def_id_to_ast(db, self.def_id))
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc<ast::TypeDef>) {
+        def_id_to_ast(db, self.def_id)
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 8668d6c8a..331b0500e 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -148,13 +148,13 @@ impl Module {
             } else {
                 return Ok(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()));
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 3b2498d5a..6229f9778 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -37,17 +37,17 @@ pub trait HirDatabase: SyntaxDatabase
         use fn query_definitions::fn_scopes;
     }
 
-    fn struct_data(def_id: DefId) -> Cancelable<Arc<StructData>> {
+    fn struct_data(def_id: DefId) -> Arc<StructData> {
         type StructDataQuery;
         use fn crate::adt::StructData::struct_data_query;
     }
 
-    fn enum_data(def_id: DefId) -> Cancelable<Arc<EnumData>> {
+    fn enum_data(def_id: DefId) -> Arc<EnumData> {
         type EnumDataQuery;
         use fn crate::adt::EnumData::enum_data_query;
     }
 
-    fn enum_variant_data(def_id: DefId) -> Cancelable<Arc<EnumVariantData>> {
+    fn enum_variant_data(def_id: DefId) -> Arc<EnumVariantData> {
         type EnumVariantDataQuery;
         use fn crate::adt::EnumVariantData::enum_variant_data_query;
     }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 5081466a2..a1e8da348 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -832,10 +832,10 @@ pub(crate) fn body_syntax_mapping(
     db: &impl HirDatabase,
     def_id: DefId,
 ) -> Cancelable<Arc<BodySyntaxMapping>> {
-    let def = def_id.resolve(db)?;
+    let def = def_id.resolve(db);
 
     let body_syntax_mapping = match def {
-        Def::Function(f) => collect_fn_body_syntax(&f.source(db)?.1),
+        Def::Function(f) => collect_fn_body_syntax(&f.source(db).1),
         // TODO: consts, etc.
         _ => panic!("Trying to get body for item type without body"),
     };
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 7b572061a..3cbf8070f 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -159,9 +159,9 @@ impl DefId {
         db.as_ref().id2loc(self)
     }
 
-    pub fn resolve(self, db: &impl HirDatabase) -> Cancelable<Def> {
+    pub fn resolve(self, db: &impl HirDatabase) -> Def {
         let loc = self.loc(db);
-        let res = match loc.kind {
+        match loc.kind {
             DefKind::Module => {
                 let module = Module::from_module_id(db, loc.source_root_id, loc.module_id);
                 Def::Module(module)
@@ -195,8 +195,7 @@ impl DefId {
 
             DefKind::StructCtor => Def::Item,
             DefKind::Item => Def::Item,
-        };
-        Ok(res)
+        }
     }
 
     pub(crate) fn source(self, db: &impl HirDatabase) -> (HirFileId, TreeArc<SyntaxNode>) {
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 03787bd89..3607969ed 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -463,25 +463,25 @@ fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
 fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Cancelable<Ty> {
     Ok(Ty::Adt {
         def_id: s.def_id(),
-        name: s.name(db)?.unwrap_or_else(Name::missing),
+        name: s.name(db).unwrap_or_else(Name::missing),
     })
 }
 
 pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Cancelable<Ty> {
     Ok(Ty::Adt {
         def_id: s.def_id(),
-        name: s.name(db)?.unwrap_or_else(Name::missing),
+        name: s.name(db).unwrap_or_else(Name::missing),
     })
 }
 
 pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> Cancelable<Ty> {
-    let enum_parent = ev.parent_enum(db)?;
+    let enum_parent = ev.parent_enum(db);
 
     type_for_enum(db, enum_parent)
 }
 
 pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ty> {
-    let def = def_id.resolve(db)?;
+    let def = def_id.resolve(db);
     match def {
         Def::Module(..) => {
             log::debug!("trying to get type for module {:?}", def_id);
@@ -507,10 +507,10 @@ pub(super) fn type_for_field(
     def_id: DefId,
     field: Name,
 ) -> Cancelable<Option<Ty>> {
-    let def = def_id.resolve(db)?;
+    let def = def_id.resolve(db);
     let variant_data = match def {
         Def::Struct(s) => s.variant_data(db)?,
-        Def::EnumVariant(ev) => ev.variant_data(db)?,
+        Def::EnumVariant(ev) => ev.variant_data(db),
         // TODO: unions
         _ => panic!(
             "trying to get type for field in non-struct/variant {:?}",
@@ -877,7 +877,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         } else {
             return Ok((Ty::Unknown, None));
         };
-        Ok(match def_id.resolve(self.db)? {
+        Ok(match def_id.resolve(self.db) {
             Def::Struct(s) => {
                 let ty = type_for_struct(self.db, s)?;
                 (ty, Some(def_id))