Clean up after if chain removal

clippy_lints/Cargo.toml

@@ -14,7 +14,6 @@ cargo_metadata = "0.15.3"
 clippy_config = { path = "../clippy_config" }
 clippy_utils = { path = "../clippy_utils" }
 declare_clippy_lint = { path = "../declare_clippy_lint" }
-if_chain = "1.0"
 itertools = "0.10.1"
 quine-mc_cluskey = "0.2"
 regex-syntax = "0.7"

clippy_lints/src/attrs.rs

@@ -5,7 +5,6 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
-use if_chain::if_chain;
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::TokenTree;
 use rustc_ast::{

clippy_lints/src/blocks_in_if_conditions.rs

@@ -4,7 +4,6 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{get_parent_expr, higher};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};

clippy_lints/src/booleans.rs

@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};

clippy_lints/src/borrow_deref_ref.rs

@@ -54,25 +54,25 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
             && !addrof_target.span.from_expansion()
             && let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind
             && !deref_target.span.from_expansion()
-            && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) )
+            && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..))
             && let ref_ty = cx.typeck_results().expr_ty(deref_target)
             && let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind()
             && !is_from_proc_macro(cx, e)
         {
-
-            if let Some(parent_expr) = get_parent_expr(cx, e){
-                if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) &&
-                   !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id) {
+            if let Some(parent_expr) = get_parent_expr(cx, e) {
+                if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..))
+                    && !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id)
+                {
                     return;
                 }
 
                 // modification to `&mut &*x` is different from `&mut x`
-                if matches!(deref_target.kind, ExprKind::Path(..)
-                                         | ExprKind::Field(..)
-                                         | ExprKind::Index(..)
-                                         | ExprKind::Unary(UnOp::Deref, ..))
-                 && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _)) {
-                   return;
+                if matches!(
+                    deref_target.kind,
+                    ExprKind::Path(..) | ExprKind::Field(..) | ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, ..)
+                ) && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _))
+                {
+                    return;
                 }
             }
 
@@ -86,12 +86,12 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                         e.span,
                         "if you would like to reborrow, try removing `&*`",
                         snippet_opt(cx, deref_target.span).unwrap(),
-                        Applicability::MachineApplicable
+                        Applicability::MachineApplicable,
                     );
 
                     // has deref trait -> give 2 help
                     // doesn't have deref trait -> give 1 help
-                    if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait(){
+                    if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait() {
                         if !implements_trait(cx, *inner_ty, deref_trait_id, &[]) {
                             return;
                         }
@@ -100,16 +100,11 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                     diag.span_suggestion(
                         e.span,
                         "if you would like to deref, try using `&**`",
-                        format!(
-                            "&**{}",
-                            &snippet_opt(cx, deref_target.span).unwrap(),
-                         ),
-                        Applicability::MaybeIncorrect
+                        format!("&**{}", &snippet_opt(cx, deref_target.span).unwrap()),
+                        Applicability::MaybeIncorrect,
                     );
-
-                }
+                },
             );
-
         }
     }
 }

clippy_lints/src/cargo/multiple_crate_versions.rs

@@ -2,7 +2,6 @@
 
 use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_lint::LateContext;
@@ -16,9 +15,13 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
     packages.sort_by(|a, b| a.name.cmp(&b.name));
 
     if let Some(resolve) = &metadata.resolve
-        && let Some(local_id) = packages
-            .iter()
-            .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None })
+        && let Some(local_id) = packages.iter().find_map(|p| {
+            if p.name == local_name.as_str() {
+                Some(&p.id)
+            } else {
+                None
+            }
+        })
     {
         for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
             let group: Vec<&Package> = group.collect();

clippy_lints/src/cargo/wildcard_dependencies.rs

@@ -1,6 +1,5 @@
 use cargo_metadata::Metadata;
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use rustc_lint::LateContext;
 use rustc_span::source_map::DUMMY_SP;
 

clippy_lints/src/casts/cast_sign_loss.rs

@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{method_chain_args, sext};
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};

clippy_lints/src/casts/cast_slice_different_sizes.rs

@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source;
-use if_chain::if_chain;
 use rustc_ast::Mutability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::LateContext;

clippy_lints/src/casts/cast_slice_from_raw_parts.rs

@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
@@ -37,7 +36,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
     {
         let func = match rpk {
             RawPartsKind::Immutable => "from_raw_parts",
-            RawPartsKind::Mutable => "from_raw_parts_mut"
+            RawPartsKind::Mutable => "from_raw_parts_mut",
         };
         let span = expr.span;
         let mut applicability = Applicability::MachineApplicable;
@@ -50,7 +49,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             &format!("casting the result of `{func}` to {cast_to}"),
             "replace with",
             format!("core::ptr::slice_{func}({ptr}, {len})"),
-            applicability
+            applicability,
         );
     }
 }

clippy_lints/src/casts/char_lit_as_u8.rs

@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -34,6 +33,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                         applicability,
                     );
                 }
-        });
+            },
+        );
     }
 }

clippy_lints/src/casts/ptr_cast_constness.rs

@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -18,10 +17,18 @@ pub(super) fn check<'tcx>(
     msrv: &Msrv,
 ) {
     if msrv.meets(msrvs::POINTER_CAST_CONSTNESS)
-        && let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind()
-        && let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind()
-        && matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not))
+        && let ty::RawPtr(TypeAndMut {
+            mutbl: from_mutbl,
+            ty: from_ty,
+        }) = cast_from.kind()
+        && let ty::RawPtr(TypeAndMut {
+            mutbl: to_mutbl,
+            ty: to_ty,
+        }) = cast_to.kind()
+        && matches!(
+            (from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not)
+        )
         && from_ty == to_ty
     {
         let sugg = Sugg::hir(cx, cast_expr, "_");

clippy_lints/src/casts/unnecessary_cast.rs

@@ -3,7 +3,6 @@ use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::visitors::{for_each_expr, Visitable};
 use clippy_utils::{get_parent_expr, get_parent_node, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
-use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -52,7 +51,9 @@ pub(super) fn check<'tcx>(
             cx,
             UNNECESSARY_CAST,
             expr.span,
-            &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
+            &format!(
+                "casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"
+            ),
             "try",
             cast_str.clone(),
             Applicability::MaybeIncorrect,
@@ -87,8 +88,8 @@ pub(super) fn check<'tcx>(
     if let ExprKind::Cast(_, cast_to) = expr.kind
         && let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind
         && let Res::PrimTy(_) = path.res
-    {}
-    else {
+    {
+    } else {
         return false;
     }
 
@@ -108,10 +109,13 @@ pub(super) fn check<'tcx>(
             && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node)
             && let from_nbits = 128 - n.leading_zeros()
             && let to_nbits = fp_ty_mantissa_nbits(cast_to)
-            && from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal()
+            && from_nbits != 0
+            && to_nbits != 0
+            && from_nbits <= to_nbits
+            && num_lit.is_decimal()
         {
             lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
-            return true
+            return true;
         }
 
         match lit.node {

clippy_lints/src/checked_conversions.rs

@@ -4,7 +4,6 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -58,7 +57,6 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
         let result = if !in_constant(cx, item.hir_id)
             && !in_external_macro(cx.sess(), item.span)
             && let ExprKind::Binary(op, left, right) = &item.kind
-
         {
             match op.node {
                 BinOpKind::Ge | BinOpKind::Le => single_check(item),
@@ -192,12 +190,11 @@ impl ConversionType {
 /// Check for `expr <= (to_type::MAX as from_type)`
 fn check_upper_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
     if let ExprKind::Binary(ref op, left, right) = &expr.kind
-         && let Some((candidate, check)) = normalize_le_ge(op, left, right)
-         && let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX")
-
-     {
-         Conversion::try_new(candidate, from, to)
-     } else {
+        && let Some((candidate, check)) = normalize_le_ge(op, left, right)
+        && let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX")
+    {
+        Conversion::try_new(candidate, from, to)
+    } else {
         None
     }
 }
@@ -243,7 +240,6 @@ fn get_types_from_cast<'a>(
         // to_type::max_value(), from_type
         && let TyKind::Path(ref from_type_path) = &from_type.kind
         && let Some(from_sym) = int_ty_to_sym(from_type_path)
-
     {
         Some((limit, from_sym))
     } else {
@@ -257,7 +253,6 @@ fn get_types_from_cast<'a>(
             // `from_type::from`
             && let ExprKind::Path(ref path) = &from_func.kind
             && let Some(from_sym) = get_implementing_type(path, INTS, "from")
-
         {
             Some((limit, from_sym))
         } else {

clippy_lints/src/collapsible_if.rs

@@ -15,7 +15,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_block, snippet_block_with_applicability};
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -131,7 +130,11 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, then_span: Span, else_:
         // Prevent "elseif"
         // Check that the "else" is followed by whitespace
         let up_to_else = then_span.between(block.span);
-        let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() { !c.is_whitespace() } else { false };
+        let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() {
+            !c.is_whitespace()
+        } else {
+            false
+        };
 
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
@@ -160,21 +163,27 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
         && let ctxt = expr.span.ctxt()
         && inner.span.ctxt() == ctxt
     {
-        span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
-            let mut app = Applicability::MachineApplicable;
-            let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
-            let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
-            diag.span_suggestion(
-                expr.span,
-                "collapse nested if block",
-                format!(
-                    "if {} {}",
-                    lhs.and(&rhs),
-                    snippet_block(cx, content.span, "..", Some(expr.span)),
-                ),
-                app, // snippet
-            );
-        });
+        span_lint_and_then(
+            cx,
+            COLLAPSIBLE_IF,
+            expr.span,
+            "this `if` statement can be collapsed",
+            |diag| {
+                let mut app = Applicability::MachineApplicable;
+                let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
+                let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
+                diag.span_suggestion(
+                    expr.span,
+                    "collapse nested if block",
+                    format!(
+                        "if {} {}",
+                        lhs.and(&rhs),
+                        snippet_block(cx, content.span, "..", Some(expr.span)),
+                    ),
+                    app, // snippet
+                );
+            },
+        );
     }
 }