use let chains in hir, lint, mir

6 files changed, 155 insertions, 165 deletions

diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index eb4c3703dbd..c48fb286dc0 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -2446,16 +2446,16 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
 
         /// Determine if this expression is a "dangerous initialization".
         fn is_dangerous_init(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<InitKind> {
-            if let hir::ExprKind::Call(path_expr, args) = expr.kind {
+            if let hir::ExprKind::Call(path_expr, args) = expr.kind
                 // Find calls to `mem::{uninitialized,zeroed}` methods.
-                if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
-                    let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
-                    match cx.tcx.get_diagnostic_name(def_id) {
-                        Some(sym::mem_zeroed) => return Some(InitKind::Zeroed),
-                        Some(sym::mem_uninitialized) => return Some(InitKind::Uninit),
-                        Some(sym::transmute) if is_zero(&args[0]) => return Some(InitKind::Zeroed),
-                        _ => {}
-                    }
+                && let hir::ExprKind::Path(ref qpath) = path_expr.kind
+            {
+                let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
+                match cx.tcx.get_diagnostic_name(def_id) {
+                    Some(sym::mem_zeroed) => return Some(InitKind::Zeroed),
+                    Some(sym::mem_uninitialized) => return Some(InitKind::Uninit),
+                    Some(sym::transmute) if is_zero(&args[0]) => return Some(InitKind::Zeroed),
+                    _ => {}
                 }
             } else if let hir::ExprKind::MethodCall(_, receiver, ..) = expr.kind {
                 // Find problematic calls to `MaybeUninit::assume_init`.
@@ -2463,14 +2463,14 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
                 if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) {
                     // This is a call to *some* method named `assume_init`.
                     // See if the `self` parameter is one of the dangerous constructors.
-                    if let hir::ExprKind::Call(path_expr, _) = receiver.kind {
-                        if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
-                            let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
-                            match cx.tcx.get_diagnostic_name(def_id) {
-                                Some(sym::maybe_uninit_zeroed) => return Some(InitKind::Zeroed),
-                                Some(sym::maybe_uninit_uninit) => return Some(InitKind::Uninit),
-                                _ => {}
-                            }
+                    if let hir::ExprKind::Call(path_expr, _) = receiver.kind
+                        && let hir::ExprKind::Path(ref qpath) = path_expr.kind
+                    {
+                        let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
+                        match cx.tcx.get_diagnostic_name(def_id) {
+                            Some(sym::maybe_uninit_zeroed) => return Some(InitKind::Zeroed),
+                            Some(sym::maybe_uninit_uninit) => return Some(InitKind::Uninit),
+                            _ => {}
                         }
                     }
                 }
@@ -2724,13 +2724,13 @@ impl<'tcx> LateLintPass<'tcx> for DerefNullPtr {
                 }
                 // check for call to `core::ptr::null` or `core::ptr::null_mut`
                 hir::ExprKind::Call(path, _) => {
-                    if let hir::ExprKind::Path(ref qpath) = path.kind {
-                        if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() {
-                            return matches!(
-                                cx.tcx.get_diagnostic_name(def_id),
-                                Some(sym::ptr_null | sym::ptr_null_mut)
-                            );
-                        }
+                    if let hir::ExprKind::Path(ref qpath) = path.kind
+                        && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+                    {
+                        return matches!(
+                            cx.tcx.get_diagnostic_name(def_id),
+                            Some(sym::ptr_null | sym::ptr_null_mut)
+                        );
                     }
                 }
                 _ => {}
diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs
index d8fc46aa9ab..7dafcc199a3 100644
--- a/compiler/rustc_lint/src/internal.rs
+++ b/compiler/rustc_lint/src/internal.rs
@@ -411,22 +411,21 @@ declare_lint_pass!(LintPassImpl => [LINT_PASS_IMPL_WITHOUT_MACRO]);
 
 impl EarlyLintPass for LintPassImpl {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
-        if let ast::ItemKind::Impl(box ast::Impl { of_trait: Some(lint_pass), .. }) = &item.kind {
-            if let Some(last) = lint_pass.path.segments.last() {
-                if last.ident.name == sym::LintPass {
-                    let expn_data = lint_pass.path.span.ctxt().outer_expn_data();
-                    let call_site = expn_data.call_site;
-                    if expn_data.kind != ExpnKind::Macro(MacroKind::Bang, sym::impl_lint_pass)
-                        && call_site.ctxt().outer_expn_data().kind
-                            != ExpnKind::Macro(MacroKind::Bang, sym::declare_lint_pass)
-                    {
-                        cx.emit_span_lint(
-                            LINT_PASS_IMPL_WITHOUT_MACRO,
-                            lint_pass.path.span,
-                            LintPassByHand,
-                        );
-                    }
-                }
+        if let ast::ItemKind::Impl(box ast::Impl { of_trait: Some(lint_pass), .. }) = &item.kind
+            && let Some(last) = lint_pass.path.segments.last()
+            && last.ident.name == sym::LintPass
+        {
+            let expn_data = lint_pass.path.span.ctxt().outer_expn_data();
+            let call_site = expn_data.call_site;
+            if expn_data.kind != ExpnKind::Macro(MacroKind::Bang, sym::impl_lint_pass)
+                && call_site.ctxt().outer_expn_data().kind
+                    != ExpnKind::Macro(MacroKind::Bang, sym::declare_lint_pass)
+            {
+                cx.emit_span_lint(
+                    LINT_PASS_IMPL_WITHOUT_MACRO,
+                    lint_pass.path.span,
+                    LintPassByHand,
+                );
             }
         }
     }
diff --git a/compiler/rustc_lint/src/map_unit_fn.rs b/compiler/rustc_lint/src/map_unit_fn.rs
index af509cb786d..a8803158889 100644
--- a/compiler/rustc_lint/src/map_unit_fn.rs
+++ b/compiler/rustc_lint/src/map_unit_fn.rs
@@ -43,56 +43,50 @@ impl<'tcx> LateLintPass<'tcx> for MapUnitFn {
             return;
         }
 
-        if let StmtKind::Semi(expr) = stmt.kind {
-            if let ExprKind::MethodCall(path, receiver, args, span) = expr.kind {
-                if path.ident.name.as_str() == "map" {
-                    if receiver.span.from_expansion()
-                        || args.iter().any(|e| e.span.from_expansion())
-                        || !is_impl_slice(cx, receiver)
-                        || !is_diagnostic_name(cx, expr.hir_id, "IteratorMap")
-                    {
-                        return;
+        if let StmtKind::Semi(expr) = stmt.kind
+            && let ExprKind::MethodCall(path, receiver, args, span) = expr.kind
+        {
+            if path.ident.name.as_str() == "map" {
+                if receiver.span.from_expansion()
+                    || args.iter().any(|e| e.span.from_expansion())
+                    || !is_impl_slice(cx, receiver)
+                    || !is_diagnostic_name(cx, expr.hir_id, "IteratorMap")
+                {
+                    return;
+                }
+                let arg_ty = cx.typeck_results().expr_ty(&args[0]);
+                let default_span = args[0].span;
+                if let ty::FnDef(id, _) = arg_ty.kind() {
+                    let fn_ty = cx.tcx.fn_sig(id).skip_binder();
+                    let ret_ty = fn_ty.output().skip_binder();
+                    if is_unit_type(ret_ty) {
+                        cx.emit_span_lint(
+                            MAP_UNIT_FN,
+                            span,
+                            MappingToUnit {
+                                function_label: cx.tcx.span_of_impl(*id).unwrap_or(default_span),
+                                argument_label: args[0].span,
+                                map_label: span,
+                                suggestion: path.ident.span,
+                                replace: "for_each".to_string(),
+                            },
+                        )
                     }
-                    let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-                    let default_span = args[0].span;
-                    if let ty::FnDef(id, _) = arg_ty.kind() {
-                        let fn_ty = cx.tcx.fn_sig(id).skip_binder();
-                        let ret_ty = fn_ty.output().skip_binder();
-                        if is_unit_type(ret_ty) {
-                            cx.emit_span_lint(
-                                MAP_UNIT_FN,
-                                span,
-                                MappingToUnit {
-                                    function_label: cx
-                                        .tcx
-                                        .span_of_impl(*id)
-                                        .unwrap_or(default_span),
-                                    argument_label: args[0].span,
-                                    map_label: span,
-                                    suggestion: path.ident.span,
-                                    replace: "for_each".to_string(),
-                                },
-                            )
-                        }
-                    } else if let ty::Closure(id, subs) = arg_ty.kind() {
-                        let cl_ty = subs.as_closure().sig();
-                        let ret_ty = cl_ty.output().skip_binder();
-                        if is_unit_type(ret_ty) {
-                            cx.emit_span_lint(
-                                MAP_UNIT_FN,
-                                span,
-                                MappingToUnit {
-                                    function_label: cx
-                                        .tcx
-                                        .span_of_impl(*id)
-                                        .unwrap_or(default_span),
-                                    argument_label: args[0].span,
-                                    map_label: span,
-                                    suggestion: path.ident.span,
-                                    replace: "for_each".to_string(),
-                                },
-                            )
-                        }
+                } else if let ty::Closure(id, subs) = arg_ty.kind() {
+                    let cl_ty = subs.as_closure().sig();
+                    let ret_ty = cl_ty.output().skip_binder();
+                    if is_unit_type(ret_ty) {
+                        cx.emit_span_lint(
+                            MAP_UNIT_FN,
+                            span,
+                            MappingToUnit {
+                                function_label: cx.tcx.span_of_impl(*id).unwrap_or(default_span),
+                                argument_label: args[0].span,
+                                map_label: span,
+                                suggestion: path.ident.span,
+                                replace: "for_each".to_string(),
+                            },
+                        )
                     }
                 }
             }
@@ -101,10 +95,10 @@ impl<'tcx> LateLintPass<'tcx> for MapUnitFn {
 }
 
 fn is_impl_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id) {
-            return cx.tcx.type_of(impl_id).skip_binder().is_slice();
-        }
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+    {
+        return cx.tcx.type_of(impl_id).skip_binder().is_slice();
     }
     false
 }
@@ -114,11 +108,11 @@ fn is_unit_type(ty: Ty<'_>) -> bool {
 }
 
 fn is_diagnostic_name(cx: &LateContext<'_>, id: HirId, name: &str) -> bool {
-    if let Some(def_id) = cx.typeck_results().type_dependent_def_id(id) {
-        if let Some(item) = cx.tcx.get_diagnostic_name(def_id) {
-            if item.as_str() == name {
-                return true;
-            }
+    if let Some(def_id) = cx.typeck_results().type_dependent_def_id(id)
+        && let Some(item) = cx.tcx.get_diagnostic_name(def_id)
+    {
+        if item.as_str() == name {
+            return true;
         }
     }
     false
diff --git a/compiler/rustc_lint/src/non_fmt_panic.rs b/compiler/rustc_lint/src/non_fmt_panic.rs
index 16c06100808..2eabeeaa88f 100644
--- a/compiler/rustc_lint/src/non_fmt_panic.rs
+++ b/compiler/rustc_lint/src/non_fmt_panic.rs
@@ -48,39 +48,39 @@ declare_lint_pass!(NonPanicFmt => [NON_FMT_PANICS]);
 
 impl<'tcx> LateLintPass<'tcx> for NonPanicFmt {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
-        if let hir::ExprKind::Call(f, [arg]) = &expr.kind {
-            if let &ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(f).kind() {
-                let f_diagnostic_name = cx.tcx.get_diagnostic_name(def_id);
+        if let hir::ExprKind::Call(f, [arg]) = &expr.kind
+            && let &ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(f).kind()
+        {
+            let f_diagnostic_name = cx.tcx.get_diagnostic_name(def_id);
 
-                if cx.tcx.is_lang_item(def_id, LangItem::BeginPanic)
-                    || cx.tcx.is_lang_item(def_id, LangItem::Panic)
-                    || f_diagnostic_name == Some(sym::panic_str_2015)
-                {
-                    if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
-                        if matches!(
-                            cx.tcx.get_diagnostic_name(id),
-                            Some(sym::core_panic_2015_macro | sym::std_panic_2015_macro)
-                        ) {
-                            check_panic(cx, f, arg);
-                        }
-                    }
-                } else if f_diagnostic_name == Some(sym::unreachable_display) {
-                    if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
-                        if cx.tcx.is_diagnostic_item(sym::unreachable_2015_macro, id) {
-                            check_panic(
-                                cx,
-                                f,
-                                // This is safe because we checked above that the callee is indeed
-                                // unreachable_display
-                                match &arg.kind {
-                                    // Get the borrowed arg not the borrow
-                                    hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, arg) => arg,
-                                    _ => bug!("call to unreachable_display without borrow"),
-                                },
-                            );
-                        }
+            if cx.tcx.is_lang_item(def_id, LangItem::BeginPanic)
+                || cx.tcx.is_lang_item(def_id, LangItem::Panic)
+                || f_diagnostic_name == Some(sym::panic_str_2015)
+            {
+                if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id {
+                    if matches!(
+                        cx.tcx.get_diagnostic_name(id),
+                        Some(sym::core_panic_2015_macro | sym::std_panic_2015_macro)
+                    ) {
+                        check_panic(cx, f, arg);
                     }
                 }
+            } else if f_diagnostic_name == Some(sym::unreachable_display) {
+                if let Some(id) = f.span.ctxt().outer_expn_data().macro_def_id
+                    && cx.tcx.is_diagnostic_item(sym::unreachable_2015_macro, id)
+                {
+                    check_panic(
+                        cx,
+                        f,
+                        // This is safe because we checked above that the callee is indeed
+                        // unreachable_display
+                        match &arg.kind {
+                            // Get the borrowed arg not the borrow
+                            hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, arg) => arg,
+                            _ => bug!("call to unreachable_display without borrow"),
+                        },
+                    );
+                }
             }
         }
     }
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index db89396d1dc..76e374deef6 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -623,15 +623,15 @@ impl<'tcx> LateLintPass<'tcx> for NonUpperCaseGlobals {
             ..
         }) = p.kind
         {
-            if let Res::Def(DefKind::Const, _) = path.res {
-                if let [segment] = path.segments {
-                    NonUpperCaseGlobals::check_upper_case(
-                        cx,
-                        "constant in pattern",
-                        None,
-                        &segment.ident,
-                    );
-                }
+            if let Res::Def(DefKind::Const, _) = path.res
+                && let [segment] = path.segments
+            {
+                NonUpperCaseGlobals::check_upper_case(
+                    cx,
+                    "constant in pattern",
+                    None,
+                    &segment.ident,
+                );
             }
         }
     }
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index a9eb1739f7f..13dd6cb1661 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -562,20 +562,19 @@ declare_lint_pass!(PathStatements => [PATH_STATEMENTS]);
 
 impl<'tcx> LateLintPass<'tcx> for PathStatements {
     fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
-        if let hir::StmtKind::Semi(expr) = s.kind {
-            if let hir::ExprKind::Path(_) = expr.kind {
-                let ty = cx.typeck_results().expr_ty(expr);
-                if ty.needs_drop(cx.tcx, cx.typing_env()) {
-                    let sub = if let Ok(snippet) = cx.sess().source_map().span_to_snippet(expr.span)
-                    {
-                        PathStatementDropSub::Suggestion { span: s.span, snippet }
-                    } else {
-                        PathStatementDropSub::Help { span: s.span }
-                    };
-                    cx.emit_span_lint(PATH_STATEMENTS, s.span, PathStatementDrop { sub })
+        if let hir::StmtKind::Semi(expr) = s.kind
+            && let hir::ExprKind::Path(_) = expr.kind
+        {
+            let ty = cx.typeck_results().expr_ty(expr);
+            if ty.needs_drop(cx.tcx, cx.typing_env()) {
+                let sub = if let Ok(snippet) = cx.sess().source_map().span_to_snippet(expr.span) {
+                    PathStatementDropSub::Suggestion { span: s.span, snippet }
                 } else {
-                    cx.emit_span_lint(PATH_STATEMENTS, s.span, PathStatementNoEffect);
-                }
+                    PathStatementDropSub::Help { span: s.span }
+                };
+                cx.emit_span_lint(PATH_STATEMENTS, s.span, PathStatementDrop { sub })
+            } else {
+                cx.emit_span_lint(PATH_STATEMENTS, s.span, PathStatementNoEffect);
             }
         }
     }
@@ -1509,21 +1508,19 @@ impl UnusedDelimLint for UnusedBraces {
                 //      let _: A<{produces_literal!()}>;
                 //      ```
                 // FIXME(const_generics): handle paths when #67075 is fixed.
-                if let [stmt] = inner.stmts.as_slice() {
-                    if let ast::StmtKind::Expr(ref expr) = stmt.kind {
-                        if !Self::is_expr_delims_necessary(expr, ctx, followed_by_block)
-                            && (ctx != UnusedDelimsCtx::AnonConst
-                                || (matches!(expr.kind, ast::ExprKind::Lit(_))
-                                    && !expr.span.from_expansion()))
-                            && ctx != UnusedDelimsCtx::ClosureBody
-                            && !cx.sess().source_map().is_multiline(value.span)
-                            && value.attrs.is_empty()
-                            && !value.span.from_expansion()
-                            && !inner.span.from_expansion()
-                        {
-                            self.emit_unused_delims_expr(cx, value, ctx, left_pos, right_pos, is_kw)
-                        }
-                    }
+                if let [stmt] = inner.stmts.as_slice()
+                    && let ast::StmtKind::Expr(ref expr) = stmt.kind
+                    && !Self::is_expr_delims_necessary(expr, ctx, followed_by_block)
+                    && (ctx != UnusedDelimsCtx::AnonConst
+                        || (matches!(expr.kind, ast::ExprKind::Lit(_))
+                            && !expr.span.from_expansion()))
+                    && ctx != UnusedDelimsCtx::ClosureBody
+                    && !cx.sess().source_map().is_multiline(value.span)
+                    && value.attrs.is_empty()
+                    && !value.span.from_expansion()
+                    && !inner.span.from_expansion()
+                {
+                    self.emit_unused_delims_expr(cx, value, ctx, left_pos, right_pos, is_kw)
                 }
             }
             ast::ExprKind::Let(_, ref expr, _, _) => {