Dogfood and rustfmt

Author: oli-obk

clippy_lints/src/booleans.rs

@@ -50,10 +50,7 @@ declare_clippy_lint! {
 }
 
 // For each pairs, both orders are considered.
-const METHODS_WITH_NEGATION: [(&str, &str); 2] = [
-    ("is_some", "is_none"),
-    ("is_err", "is_ok"),
-];
+const METHODS_WITH_NEGATION: [(&str, &str); 2] = [("is_some", "is_none"), ("is_err", "is_ok")];
 
 declare_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, LOGIC_BUG]);
 

clippy_lints/src/len_zero.rs

@@ -139,8 +139,7 @@ fn check_trait_items(cx: &LateContext<'_, '_>, visited_trait: &Item, trait_items
         }
     }
 
-    if cx.access_levels.is_exported(visited_trait.hir_id) && trait_items.iter().any(|i| is_named_self(cx, i, "len"))
-    {
+    if cx.access_levels.is_exported(visited_trait.hir_id) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) {
         let mut current_and_super_traits = FxHashSet::default();
         let visited_trait_def_id = cx.tcx.hir().local_def_id_from_hir_id(visited_trait.hir_id);
         fill_trait_set(visited_trait_def_id, &mut current_and_super_traits, cx);

clippy_lints/src/methods/mod.rs

@@ -1111,8 +1111,7 @@ fn lint_or_fun_call<'a, 'tcx: 'a>(
 
                 if ["default", "new"].contains(&path) {
                     let arg_ty = cx.tables.expr_ty(arg);
-                    let default_trait_id = if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT)
-                    {
+                    let default_trait_id = if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT) {
                         default_trait_id
                     } else {
                         return false;
@@ -2254,33 +2253,15 @@ fn lint_chars_cmp_with_unwrap<'a, 'tcx>(
 
 /// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
 fn lint_chars_next_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    lint_chars_cmp_with_unwrap(
-        cx,
-        info,
-        &["chars", "next", "unwrap"],
-        CHARS_NEXT_CMP,
-        "starts_with",
-    )
+    lint_chars_cmp_with_unwrap(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
 }
 
 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
 fn lint_chars_last_cmp_with_unwrap<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if lint_chars_cmp_with_unwrap(
-        cx,
-        info,
-        &["chars", "last", "unwrap"],
-        CHARS_LAST_CMP,
-        "ends_with",
-    ) {
+    if lint_chars_cmp_with_unwrap(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
         true
     } else {
-        lint_chars_cmp_with_unwrap(
-            cx,
-            info,
-            &["chars", "next_back", "unwrap"],
-            CHARS_LAST_CMP,
-            "ends_with",
-        )
+        lint_chars_cmp_with_unwrap(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
     }
 }
 
@@ -2344,7 +2325,10 @@ fn lint_asref(cx: &LateContext<'_, '_>, expr: &hir::Expr, call_name: &str, as_re
     }
 }
 
-fn ty_has_iter_method(cx: &LateContext<'_, '_>, self_ref_ty: Ty<'_>) -> Option<(&'static Lint, &'static str, &'static str)> {
+fn ty_has_iter_method(
+    cx: &LateContext<'_, '_>,
+    self_ref_ty: Ty<'_>,
+) -> Option<(&'static Lint, &'static str, &'static str)> {
     if let Some(ty_name) = has_iter_method(cx, self_ref_ty) {
         let lint = if ty_name == "array" || ty_name == "PathBuf" {
             INTO_ITER_ON_ARRAY

clippy_lints/src/misc.rs

@@ -504,8 +504,7 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr, other: &Expr) {
         },
         ExprKind::Call(ref path, ref v) if v.len() == 1 => {
             if let ExprKind::Path(ref path) = path.node {
-                if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"])
-                {
+                if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"]) {
                     (cx.tables.expr_ty_adjusted(&v[0]), snippet(cx, v[0].span, ".."))
                 } else {
                     return;

clippy_lints/src/ptr.rs

@@ -193,12 +193,7 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl, fn_id: HirId, opt_body_id:
                     );
                 }
             } else if match_type(cx, ty, &paths::STRING) {
-                if let Some(spans) = get_spans(
-                    cx,
-                    opt_body_id,
-                    idx,
-                    &[("clone", ".to_string()"), ("as_str", "")],
-                ) {
+                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) {
                     span_lint_and_then(
                         cx,
                         PTR_ARG,

clippy_lints/src/ranges.rs

@@ -212,8 +212,7 @@ fn has_step_by(cx: &LateContext<'_, '_>, expr: &Expr) -> bool {
     // can't be called on a borrowed range.
     let ty = cx.tables.expr_ty_adjusted(expr);
 
-    get_trait_def_id(cx, &paths::ITERATOR)
-        .map_or(false, |iterator_trait| implements_trait(cx, ty, iterator_trait, &[]))
+    get_trait_def_id(cx, &paths::ITERATOR).map_or(false, |iterator_trait| implements_trait(cx, ty, iterator_trait, &[]))
 }
 
 fn y_plus_one(expr: &Expr) -> Option<&Expr> {

clippy_lints/src/redundant_clone.rs

@@ -96,8 +96,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantClone {
 
             let from_borrow = match_def_path(cx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
                 || match_def_path(cx, fn_def_id, &paths::TO_OWNED_METHOD)
-                || (match_def_path(cx, fn_def_id, &paths::TO_STRING_METHOD)
-                    && match_type(cx, arg_ty, &paths::STRING));
+                || (match_def_path(cx, fn_def_id, &paths::TO_STRING_METHOD) && match_type(cx, arg_ty, &paths::STRING));
 
             let from_deref = !from_borrow
                 && (match_def_path(cx, fn_def_id, &paths::PATH_TO_PATH_BUF)

clippy_lints/src/replace_consts.rs

@@ -56,7 +56,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ReplaceConsts {
     }
 }
 
-const REPLACEMENTS: [([&str; 3], &'static str); 25] = [
+const REPLACEMENTS: [([&str; 3], &str); 25] = [
     // Once
     (["core", "sync", "ONCE_INIT"], "Once::new()"),
     // Min

clippy_lints/src/utils/higher.rs

@@ -100,8 +100,7 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O
         },
         hir::ExprKind::Call(ref path, ref args) => {
             if let hir::ExprKind::Path(ref path) = path.node {
-                if match_qpath(path, &paths::RANGE_INCLUSIVE_STD_NEW)
-                    || match_qpath(path, &paths::RANGE_INCLUSIVE_NEW)
+                if match_qpath(path, &paths::RANGE_INCLUSIVE_STD_NEW) || match_qpath(path, &paths::RANGE_INCLUSIVE_NEW)
                 {
                     Some(Range {
                         start: Some(&args[0]),
@@ -128,8 +127,7 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O
                     end: Some(get_field("end", fields)?),
                     limits: ast::RangeLimits::HalfOpen,
                 })
-            } else if match_qpath(path, &paths::RANGE_TO_INCLUSIVE_STD)
-                || match_qpath(path, &paths::RANGE_TO_INCLUSIVE)
+            } else if match_qpath(path, &paths::RANGE_TO_INCLUSIVE_STD) || match_qpath(path, &paths::RANGE_TO_INCLUSIVE)
             {
                 Some(Range {
                     start: None,

clippy_lints/src/utils/mod.rs

@@ -231,7 +231,9 @@ pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
 /// Gets the definition associated to a path.
 pub fn path_to_res(cx: &LateContext<'_, '_>, path: &[&str]) -> Option<(def::Res)> {
     let crates = cx.tcx.crates();
-    let krate = crates.iter().find(|&&krate| cx.tcx.crate_name(krate).as_str() == path[0]);
+    let krate = crates
+        .iter()
+        .find(|&&krate| cx.tcx.crate_name(krate).as_str() == path[0]);
     if let Some(krate) = krate {
         let krate = DefId {
             krate: *krate,