3 files changed, 10 insertions, 18 deletions

diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 4a0eabdfc..fb6a51b12 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -26,7 +26,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     /// Note that it is only possible that one type are coerced to another.
     /// Coercing both types to another least upper bound type is not possible in rustc,
     /// which will simply result in "incompatible types" error.
-    pub(super) fn coerce_merge_branch<'t>(&mut self, ty1: &Ty, ty2: &Ty) -> Ty {
+    pub(super) fn coerce_merge_branch(&mut self, ty1: &Ty, ty2: &Ty) -> Ty {
         if self.coerce(ty1, ty2) {
             ty2.clone()
         } else if self.coerce(ty2, ty1) {
@@ -252,15 +252,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let unsize_generic_index = {
                     let mut index = None;
                     let mut multiple_param = false;
-                    field_tys[last_field_id].value.walk(&mut |ty| match ty {
-                        &Ty::Bound(idx) => {
+                    field_tys[last_field_id].value.walk(&mut |ty| {
+                        if let &Ty::Bound(idx) = ty {
                             if index.is_none() {
                                 index = Some(idx);
                             } else if Some(idx) != index {
                                 multiple_param = true;
                             }
                         }
-                        _ => {}
                     });
 
                     if multiple_param {
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 0af94ae32..9d5f75625 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -35,8 +35,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
             );
         }
-        let ty = self.resolve_ty_as_possible(ty);
-        ty
+        self.resolve_ty_as_possible(ty)
     }
 
     /// Infer type of expression with possibly implicit coerce to the expected type.
@@ -155,8 +154,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 };
                 self.register_obligations_for_call(&callee_ty);
                 self.check_call_arguments(args, &param_tys);
-                let ret_ty = self.normalize_associated_types_in(ret_ty);
-                ret_ty
+                self.normalize_associated_types_in(ret_ty)
             }
             Expr::MethodCall { receiver, args, method_name, generic_args } => self
                 .infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
@@ -280,14 +278,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             }
             Expr::Await { expr } => {
                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
-                let ty =
-                    self.resolve_associated_type(inner_ty, self.resolve_future_future_output());
-                ty
+                self.resolve_associated_type(inner_ty, self.resolve_future_future_output())
             }
             Expr::Try { expr } => {
                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
-                let ty = self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok());
-                ty
+                self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok())
             }
             Expr::Cast { expr, type_ref } => {
                 let _inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
@@ -611,8 +606,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.unify(&expected_receiver_ty, &actual_receiver_ty);
 
         self.check_call_arguments(args, &param_tys);
-        let ret_ty = self.normalize_associated_types_in(ret_ty);
-        ret_ty
+        self.normalize_associated_types_in(ret_ty)
     }
 
     fn check_call_arguments(&mut self, args: &[ExprId], param_tys: &[Ty]) {
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index 1dc842f40..9c7996572 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -140,13 +140,12 @@ where
 impl<T> Canonicalized<T> {
     pub fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
         ty.walk_mut_binders(
-            &mut |ty, binders| match ty {
-                &mut Ty::Bound(idx) => {
+            &mut |ty, binders| {
+                if let &mut Ty::Bound(idx) = ty {
                     if idx as usize >= binders && (idx as usize - binders) < self.free_vars.len() {
                         *ty = Ty::Infer(self.free_vars[idx as usize - binders]);
                     }
                 }
-                _ => {}
             },
             0,
         );