fmt clippy

1 files changed, 76 insertions, 52 deletions

diff --git a/src/len_zero.rs b/src/len_zero.rs
index d574fa2c336..6bc5bc4bf01 100644
--- a/src/len_zero.rs
+++ b/src/len_zero.rs
@@ -49,21 +49,18 @@ impl LintPass for LenZero {
 impl LateLintPass for LenZero {
     fn check_item(&mut self, cx: &LateContext, item: &Item) {
         match item.node {
-            ItemTrait(_, _, _, ref trait_items) =>
-                check_trait_items(cx, item, trait_items),
-            ItemImpl(_, _, _, None, _, ref impl_items) => // only non-trait
-                check_impl_items(cx, item, impl_items),
-            _ => ()
+            ItemTrait(_, _, _, ref trait_items) => check_trait_items(cx, item, trait_items),
+            ItemImpl(_, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items),
+            _ => (),
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
-        if let ExprBinary(Spanned{node: cmp, ..}, ref left, ref right) =
-                expr.node {
+        if let ExprBinary(Spanned{node: cmp, ..}, ref left, ref right) = expr.node {
             match cmp {
                 BiEq => check_cmp(cx, expr.span, left, right, ""),
                 BiGt | BiNe => check_cmp(cx, expr.span, left, right, "!"),
-                _ => ()
+                _ => (),
             }
         }
     }
@@ -71,37 +68,52 @@ impl LateLintPass for LenZero {
 
 fn check_trait_items(cx: &LateContext, item: &Item, trait_items: &[TraitItem]) {
     fn is_named_self(item: &TraitItem, name: &str) -> bool {
-        item.name.as_str() == name && if let MethodTraitItem(ref sig, _) =
-            item.node { is_self_sig(sig) } else { false }
+        item.name.as_str() == name &&
+        if let MethodTraitItem(ref sig, _) = item.node {
+            is_self_sig(sig)
+        } else {
+            false
+        }
     }
 
     if !trait_items.iter().any(|i| is_named_self(i, "is_empty")) {
-        //span_lint(cx, LEN_WITHOUT_IS_EMPTY, item.span, &format!("trait {}", item.ident));
+        // span_lint(cx, LEN_WITHOUT_IS_EMPTY, item.span, &format!("trait {}", item.ident));
         for i in trait_items {
             if is_named_self(i, "len") {
-                span_lint(cx, LEN_WITHOUT_IS_EMPTY, i.span,
-                          &format!("trait `{}` has a `.len(_: &Self)` method, but no \
-                                    `.is_empty(_: &Self)` method. Consider adding one",
+                span_lint(cx,
+                          LEN_WITHOUT_IS_EMPTY,
+                          i.span,
+                          &format!("trait `{}` has a `.len(_: &Self)` method, but no `.is_empty(_: &Self)` method. \
+                                    Consider adding one",
                                    item.name));
             }
-        };
+        }
     }
 }
 
 fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItem]) {
     fn is_named_self(item: &ImplItem, name: &str) -> bool {
-        item.name.as_str() == name && if let ImplItemKind::Method(ref sig, _) =
-            item.node { is_self_sig(sig) } else { false }
+        item.name.as_str() == name &&
+        if let ImplItemKind::Method(ref sig, _) = item.node {
+            is_self_sig(sig)
+        } else {
+            false
+        }
     }
 
     if !impl_items.iter().any(|i| is_named_self(i, "is_empty")) {
         for i in impl_items {
             if is_named_self(i, "len") {
                 let s = i.span;
-                span_lint(cx, LEN_WITHOUT_IS_EMPTY,
-                          Span{ lo: s.lo, hi: s.lo, expn_id: s.expn_id },
-                          &format!("item `{}` has a `.len(_: &Self)` method, but no \
-                                    `.is_empty(_: &Self)` method. Consider adding one",
+                span_lint(cx,
+                          LEN_WITHOUT_IS_EMPTY,
+                          Span {
+                              lo: s.lo,
+                              hi: s.lo,
+                              expn_id: s.expn_id,
+                          },
+                          &format!("item `{}` has a `.len(_: &Self)` method, but no `.is_empty(_: &Self)` method. \
+                                    Consider adding one",
                                    item.name));
                 return;
             }
@@ -111,32 +123,40 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItem]) {
 
 fn is_self_sig(sig: &MethodSig) -> bool {
     if let SelfStatic = sig.explicit_self.node {
-        false } else { sig.decl.inputs.len() == 1 }
+        false
+    } else {
+        sig.decl.inputs.len() == 1
+    }
 }
 
 fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str) {
     // check if we are in an is_empty() method
     if let Some(name) = get_item_name(cx, left) {
-        if name.as_str() == "is_empty" { return; }
+        if name.as_str() == "is_empty" {
+            return;
+        }
     }
     match (&left.node, &right.node) {
-        (&ExprLit(ref lit), &ExprMethodCall(ref method, _, ref args)) =>
-            check_len_zero(cx, span, &method.node, args, lit, op),
-        (&ExprMethodCall(ref method, _, ref args), &ExprLit(ref lit)) =>
-            check_len_zero(cx, span, &method.node, args, lit, op),
-        _ => ()
+        (&ExprLit(ref lit), &ExprMethodCall(ref method, _, ref args)) => {
+            check_len_zero(cx, span, &method.node, args, lit, op)
+        }
+        (&ExprMethodCall(ref method, _, ref args), &ExprLit(ref lit)) => {
+            check_len_zero(cx, span, &method.node, args, lit, op)
+        }
+        _ => (),
     }
 }
 
-fn check_len_zero(cx: &LateContext, span: Span, name: &Name,
-                  args: &[P<Expr>], lit: &Lit, op: &str) {
+fn check_len_zero(cx: &LateContext, span: Span, name: &Name, args: &[P<Expr>], lit: &Lit, op: &str) {
     if let Spanned{node: LitInt(0, _), ..} = *lit {
-        if name.as_str() == "len" && args.len() == 1 &&
-            has_is_empty(cx, &args[0]) {
-                span_lint(cx, LEN_ZERO, span, &format!(
-                    "consider replacing the len comparison with `{}{}.is_empty()`",
-                    op, snippet(cx, args[0].span, "_")));
-            }
+        if name.as_str() == "len" && args.len() == 1 && has_is_empty(cx, &args[0]) {
+            span_lint(cx,
+                      LEN_ZERO,
+                      span,
+                      &format!("consider replacing the len comparison with `{}{}.is_empty()`",
+                               op,
+                               snippet(cx, args[0].span, "_")));
+        }
     }
 }
 
@@ -145,31 +165,35 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {
     /// get a ImplOrTraitItem and return true if it matches is_empty(self)
     fn is_is_empty(cx: &LateContext, id: &ImplOrTraitItemId) -> bool {
         if let MethodTraitItemId(def_id) = *id {
-            if let ty::MethodTraitItem(ref method) =
-                cx.tcx.impl_or_trait_item(def_id) {
-                    method.name.as_str() == "is_empty"
-                        && method.fty.sig.skip_binder().inputs.len() == 1
-                } else { false }
-        } else { false }
+            if let ty::MethodTraitItem(ref method) = cx.tcx.impl_or_trait_item(def_id) {
+                method.name.as_str() == "is_empty" && method.fty.sig.skip_binder().inputs.len() == 1
+            } else {
+                false
+            }
+        } else {
+            false
+        }
     }
 
     /// check the inherent impl's items for an is_empty(self) method
     fn has_is_empty_impl(cx: &LateContext, id: &DefId) -> bool {
         let impl_items = cx.tcx.impl_items.borrow();
-        cx.tcx.inherent_impls.borrow().get(id).map_or(false,
-            |ids| ids.iter().any(|iid| impl_items.get(iid).map_or(false,
-                |iids| iids.iter().any(|i| is_is_empty(cx, i)))))
+        cx.tcx.inherent_impls.borrow().get(id).map_or(false, |ids| {
+            ids.iter().any(|iid| impl_items.get(iid).map_or(false, |iids| iids.iter().any(|i| is_is_empty(cx, i))))
+        })
     }
 
     let ty = &walk_ptrs_ty(&cx.tcx.expr_ty(expr));
     match ty.sty {
-        ty::TyTrait(_) => cx.tcx.trait_item_def_ids.borrow().get(
-            &ty.ty_to_def_id().expect("trait impl not found")).map_or(false,
-                |ids| ids.iter().any(|i| is_is_empty(cx, i))),
-        ty::TyProjection(_) => ty.ty_to_def_id().map_or(false,
-            |id| has_is_empty_impl(cx, &id)),
-        ty::TyEnum(ref id, _) | ty::TyStruct(ref id, _) =>
-            has_is_empty_impl(cx, &id.did),
+        ty::TyTrait(_) => {
+            cx.tcx
+              .trait_item_def_ids
+              .borrow()
+              .get(&ty.ty_to_def_id().expect("trait impl not found"))
+              .map_or(false, |ids| ids.iter().any(|i| is_is_empty(cx, i)))
+        }
+        ty::TyProjection(_) => ty.ty_to_def_id().map_or(false, |id| has_is_empty_impl(cx, &id)),
+        ty::TyEnum(ref id, _) | ty::TyStruct(ref id, _) => has_is_empty_impl(cx, &id.did),
         ty::TyArray(..) => true,
         _ => false,
     }