2 files changed, 15 insertions, 13 deletions

diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index c99c9c869..c8ae19869 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -97,7 +97,12 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         }
     }
 
-    fn validate_results_in_tail_expr(&mut self, body_id: ExprId, id: ExprId, db: &impl HirDatabase) {
+    fn validate_results_in_tail_expr(
+        &mut self,
+        body_id: ExprId,
+        id: ExprId,
+        db: &impl HirDatabase,
+    ) {
         // the mismatch will be on the whole block currently
         let mismatch = match self.infer.type_mismatch_for_expr(body_id) {
             Some(m) => m,
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 0aa993067..812990426 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -1009,16 +1009,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 let then_ty = self.infer_expr_inner(*then_branch, &expected);
                 self.coerce(&then_ty, &expected.ty);
-                match else_branch {
-                    Some(else_branch) => {
-                        let else_ty = self.infer_expr_inner(*else_branch, &expected);
-                        self.coerce(&else_ty, &expected.ty);
-                    }
-                    None => {
-                        // no else branch -> unit
-                        self.unify(&then_ty, &Ty::unit()); // actually coerce
-                    }
+
+                let else_ty = match else_branch {
+                    Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
+                    None => Ty::unit(),
                 };
+                self.coerce(&else_ty, &expected.ty);
 
                 expected.ty.clone()
             }
@@ -1422,7 +1418,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 }
             }
         }
-        let ty = if let Some(expr) = tail { self.infer_expr_inner(expr, expected) } else { Ty::unit() };
+        let ty =
+            if let Some(expr) = tail { self.infer_expr_inner(expr, expected) } else { Ty::unit() };
         ty
     }
 
@@ -1665,8 +1662,8 @@ fn calculate_least_upper_bound(expected_ty: Ty, actual_tys: &[Ty]) -> Ty {
             all_never = false;
             least_upper_bound = match (actual_ty, &least_upper_bound) {
                 (_, Ty::Unknown)
-                    | (Ty::Infer(_), Ty::Infer(InferTy::TypeVar(_)))
-                    | (Ty::Apply(_), _) => actual_ty.clone(),
+                | (Ty::Infer(_), Ty::Infer(InferTy::TypeVar(_)))
+                | (Ty::Apply(_), _) => actual_ty.clone(),
                 _ => least_upper_bound,
             }
         }