1 files changed, 18 insertions, 18 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 03787bd89..e5f8ffc2e 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -349,7 +349,7 @@ impl Ty {
         }
 
         // Resolve in module (in type namespace)
-        let resolved = if let Some(r) = module.resolve_path(db, path)?.take_types() {
+        let resolved = if let Some(r) = module.resolve_path(db, path).take_types() {
             r
         } else {
             return Ok(Ty::Unknown);
@@ -447,8 +447,8 @@ impl fmt::Display for Ty {
 /// function body.
 fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
     let signature = f.signature(db);
-    let module = f.module(db)?;
-    let impl_block = f.impl_block(db)?;
+    let module = f.module(db);
+    let impl_block = f.impl_block(db);
     // TODO we ignore type parameters for now
     let input = signature
         .params()
@@ -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,18 +507,18 @@ 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 {:?}",
             def_id
         ),
     };
-    let module = def_id.module(db)?;
-    let impl_block = def_id.impl_block(db)?;
+    let module = def_id.module(db);
+    let impl_block = def_id.impl_block(db);
     let type_ref = ctry!(variant_data.get_field_type_ref(&field));
     Ok(Some(Ty::from_hir(
         db,
@@ -860,7 +860,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         };
 
         // resolve in module
-        let resolved = ctry!(self.module.resolve_path(self.db, &path)?.take_values());
+        let resolved = ctry!(self.module.resolve_path(self.db, &path).take_values());
         let ty = self.db.type_for_def(resolved)?;
         let ty = self.insert_type_vars(ty);
         Ok(Some(ty))
@@ -872,12 +872,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         } else {
             return Ok((Ty::Unknown, None));
         };
-        let def_id = if let Some(def_id) = self.module.resolve_path(self.db, &path)?.take_types() {
+        let def_id = if let Some(def_id) = self.module.resolve_path(self.db, &path).take_types() {
             def_id
         } 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))
@@ -1205,10 +1205,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
     db.check_canceled();
     let function = Function::new(def_id); // TODO: consts also need inference
-    let body = function.body(db)?;
-    let scopes = db.fn_scopes(def_id)?;
-    let module = function.module(db)?;
-    let impl_block = function.impl_block(db)?;
+    let body = function.body(db);
+    let scopes = db.fn_scopes(def_id);
+    let module = function.module(db);
+    let impl_block = function.impl_block(db);
     let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
 
     let signature = function.signature(db);