diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 1f2aba2b27e68..112a0efee6111 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -85,7 +85,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::AddrOf(k, m, ohs)
                 }
                 ExprKind::Let(ref pat, ref scrutinee) => {
-                    self.lower_expr_let(e.span, pat, scrutinee)
+                    hir::ExprKind::Let(self.lower_pat(pat), self.lower_expr(scrutinee))
                 }
                 ExprKind::If(ref cond, ref then, ref else_opt) => {
                     self.lower_expr_if(e.span, cond, then, else_opt.as_deref())
@@ -268,51 +268,36 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    /// Emit an error and lower `ast::ExprKind::Let(pat, scrutinee)` into:
-    /// ```rust
-    /// match scrutinee { pats => true, _ => false }
-    /// ```
-    fn lower_expr_let(&mut self, span: Span, pat: &Pat, scrutinee: &Expr) -> hir::ExprKind<'hir> {
-        // If we got here, the `let` expression is not allowed.
-
-        if self.sess.opts.unstable_features.is_nightly_build() {
-            self.sess
-                .struct_span_err(span, "`let` expressions are not supported here")
-                .note("only supported directly in conditions of `if`- and `while`-expressions")
-                .note("as well as when nested within `&&` and parenthesis in those conditions")
-                .emit();
-        } else {
-            self.sess
-                .struct_span_err(span, "expected expression, found statement (`let`)")
-                .note("variable declaration using `let` is a statement")
-                .emit();
+    /// Lower the condition of an `if` or `while` expression.
+    /// This entails some special handling of immediate `let` expressions as conditions.
+    /// Namely, if the given `cond` is not a `let` expression then it is wrapped in `drop-temps`.
+    fn lower_expr_cond(&mut self, cond: &Expr) -> &'hir hir::Expr<'hir> {
+        // Lower the `cond` expression.
+        let cond = self.lower_expr(cond);
+        // Normally, the `cond` of `if cond` will drop temporaries before evaluating the blocks.
+        // This is achieved by using `drop-temps { cond }`, equivalent to `{ let _t = $cond; _t }`.
+        // However, for backwards compatibility reasons, `if let pat = scrutinee`, like `match`
+        // does not drop the temporaries of `scrutinee` before evaluating the blocks.
+        match cond.kind {
+            hir::ExprKind::Let(..) => cond,
+            _ => {
+                let reason = DesugaringKind::CondTemporary;
+                let span = self.mark_span_with_reason(reason, cond.span, None);
+                self.expr_drop_temps(span, cond, ThinVec::new())
+            }
         }
+    }
 
-        // For better recovery, we emit:
-        // ```
-        // match scrutinee { pat => true, _ => false }
-        // ```
-        // While this doesn't fully match the user's intent, it has key advantages:
-        // 1. We can avoid using `abort_if_errors`.
-        // 2. We can typeck both `pat` and `scrutinee`.
-        // 3. `pat` is allowed to be refutable.
-        // 4. The return type of the block is `bool` which seems like what the user wanted.
-        let scrutinee = self.lower_expr(scrutinee);
-        let then_arm = {
-            let pat = self.lower_pat(pat);
-            let expr = self.expr_bool(span, true);
-            self.arm(pat, expr)
-        };
-        let else_arm = {
-            let pat = self.pat_wild(span);
-            let expr = self.expr_bool(span, false);
-            self.arm(pat, expr)
-        };
-        hir::ExprKind::Match(
-            scrutinee,
-            arena_vec![self; then_arm, else_arm],
-            hir::MatchSource::Normal,
-        )
+    /// Lower `then` into `true => then`.
+    fn lower_then_arm(&mut self, span: Span, then: &Block) -> hir::Arm<'hir> {
+        let then_expr = self.lower_block_expr(then);
+        let then_pat = self.pat_bool(span, true);
+        self.arm(then_pat, self.arena.alloc(then_expr))
+    }
+
+    fn lower_else_arm(&mut self, span: Span, else_expr: &'hir hir::Expr<'hir>) -> hir::Arm<'hir> {
+        let else_pat = self.pat_wild(span);
+        self.arm(else_pat, else_expr)
     }
 
     fn lower_expr_if(
@@ -322,44 +307,29 @@ impl<'hir> LoweringContext<'_, 'hir> {
         then: &Block,
         else_opt: Option<&Expr>,
     ) -> hir::ExprKind<'hir> {
-        // FIXME(#53667): handle lowering of && and parens.
-
-        // `_ => else_block` where `else_block` is `{}` if there's `None`:
-        let else_pat = self.pat_wild(span);
-        let (else_expr, contains_else_clause) = match else_opt {
-            None => (self.expr_block_empty(span), false),
-            Some(els) => (self.lower_expr(els), true),
+        let scrutinee = self.lower_expr_cond(cond);
+        let then_arm = self.lower_then_arm(span, then);
+        let else_expr = match else_opt {
+            None => self.expr_block_empty(span), // Use `{}` if there's no `else` block.
+            Some(els) => self.lower_expr(els),
         };
-        let else_arm = self.arm(else_pat, else_expr);
-
-        // Handle then + scrutinee:
-        let then_expr = self.lower_block_expr(then);
-        let (then_pat, scrutinee, desugar) = match cond.kind {
-            // `<pat> => <then>`:
-            ExprKind::Let(ref pat, ref scrutinee) => {
-                let scrutinee = self.lower_expr(scrutinee);
-                let pat = self.lower_pat(pat);
-                (pat, scrutinee, hir::MatchSource::IfLetDesugar { contains_else_clause })
-            }
-            // `true => <then>`:
-            _ => {
-                // Lower condition:
-                let cond = self.lower_expr(cond);
-                let span_block =
-                    self.mark_span_with_reason(DesugaringKind::CondTemporary, cond.span, None);
-                // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
-                // to preserve drop semantics since `if cond { ... }` does not
-                // let temporaries live outside of `cond`.
-                let cond = self.expr_drop_temps(span_block, cond, ThinVec::new());
-                let pat = self.pat_bool(span, true);
-                (pat, cond, hir::MatchSource::IfDesugar { contains_else_clause })
-            }
-        };
-        let then_arm = self.arm(then_pat, self.arena.alloc(then_expr));
-
+        let else_arm = self.lower_else_arm(span, else_expr);
+        let desugar = hir::MatchSource::IfDesugar { contains_else_clause: else_opt.is_some() };
         hir::ExprKind::Match(scrutinee, arena_vec![self; then_arm, else_arm], desugar)
     }
 
+    /// We desugar: `'label: while $cond $body` into:
+    ///
+    /// ```
+    /// 'label: loop {
+    ///     match $cond {
+    ///         true => $body,
+    ///         _ => break,
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// where `$cond` is wrapped in `drop-temps { $cond }` if it isn't a `Let` expression.
     fn lower_expr_while_in_loop_scope(
         &mut self,
         span: Span,
@@ -367,67 +337,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
-        // FIXME(#53667): handle lowering of && and parens.
-
         // Note that the block AND the condition are evaluated in the loop scope.
         // This is done to allow `break` from inside the condition of the loop.
 
+        // Lower the condition:
+        let scrutinee = self.with_loop_condition_scope(|t| t.lower_expr_cond(cond));
+        // `true => body`:
+        let then_arm = self.lower_then_arm(span, body);
         // `_ => break`:
-        let else_arm = {
-            let else_pat = self.pat_wild(span);
-            let else_expr = self.expr_break(span, ThinVec::new());
-            self.arm(else_pat, else_expr)
-        };
-
-        // Handle then + scrutinee:
-        let then_expr = self.lower_block_expr(body);
-        let (then_pat, scrutinee, desugar, source) = match cond.kind {
-            ExprKind::Let(ref pat, ref scrutinee) => {
-                // to:
-                //
-                //   [opt_ident]: loop {
-                //     match <sub_expr> {
-                //       <pat> => <body>,
-                //       _ => break
-                //     }
-                //   }
-                let scrutinee = self.with_loop_condition_scope(|t| t.lower_expr(scrutinee));
-                let pat = self.lower_pat(pat);
-                (pat, scrutinee, hir::MatchSource::WhileLetDesugar, hir::LoopSource::WhileLet)
-            }
-            _ => {
-                // We desugar: `'label: while $cond $body` into:
-                //
-                // ```
-                // 'label: loop {
-                //     match drop-temps { $cond } {
-                //         true => $body,
-                //         _ => break,
-                //     }
-                // }
-                // ```
-
-                // Lower condition:
-                let cond = self.with_loop_condition_scope(|this| this.lower_expr(cond));
-                let span_block =
-                    self.mark_span_with_reason(DesugaringKind::CondTemporary, cond.span, None);
-                // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
-                // to preserve drop semantics since `while cond { ... }` does not
-                // let temporaries live outside of `cond`.
-                let cond = self.expr_drop_temps(span_block, cond, ThinVec::new());
-                // `true => <then>`:
-                let pat = self.pat_bool(span, true);
-                (pat, cond, hir::MatchSource::WhileDesugar, hir::LoopSource::While)
-            }
-        };
-        let then_arm = self.arm(then_pat, self.arena.alloc(then_expr));
-
+        let else_expr = self.expr_break(span, ThinVec::new());
+        let else_arm = self.lower_else_arm(span, else_expr);
         // `match <scrutinee> { ... }`
-        let match_expr =
-            self.expr_match(span, scrutinee, arena_vec![self; then_arm, else_arm], desugar);
-
+        let match_arms = arena_vec![self; then_arm, else_arm];
+        let match_desugar = hir::MatchSource::WhileDesugar;
+        let match_expr = self.expr_match(span, scrutinee, match_arms, match_desugar);
         // `[opt_ident]: loop { ... }`
-        hir::ExprKind::Loop(self.block_expr(self.arena.alloc(match_expr)), opt_label, source)
+        let loop_block = self.block_expr(self.arena.alloc(match_expr));
+        hir::ExprKind::Loop(loop_block, opt_label, hir::LoopSource::While)
     }
 
     /// Desugar `try { <stmts>; <expr> }` into `{ <stmts>; ::std::ops::Try::from_ok(<expr>) }`,
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index bb1d2967d6a4e..83deb7bacf7cf 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -80,6 +80,9 @@ struct AstValidator<'a> {
     /// certain positions.
     is_assoc_ty_bound_banned: bool,
 
+    /// Used to allow `let` expressions in certain syntactic locations.
+    is_let_allowed: bool,
+
     lint_buffer: &'a mut LintBuffer,
 }
 
@@ -118,6 +121,27 @@ impl<'a> AstValidator<'a> {
         self.bound_context = old;
     }
 
+    fn with_let_allowed(&mut self, allowed: bool, f: impl FnOnce(&mut Self, bool)) {
+        let old = mem::replace(&mut self.is_let_allowed, allowed);
+        f(self, old);
+        self.is_let_allowed = old;
+    }
+
+    /// Emits an error banning the `let` expression provided in the given location.
+    fn ban_let_expr(&self, expr: &'a Expr) {
+        let sess = &self.session;
+        if sess.opts.unstable_features.is_nightly_build() {
+            sess.struct_span_err(expr.span, "`let` expressions are not supported here")
+                .note("only supported directly in conditions of `if`- and `while`-expressions")
+                .note("as well as when nested within `&&` and parenthesis in those conditions")
+                .emit();
+        } else {
+            sess.struct_span_err(expr.span, "expected expression, found statement (`let`)")
+                .note("variable declaration using `let` is a statement")
+                .emit();
+        }
+    }
+
     fn visit_assoc_ty_constraint_from_generic_args(&mut self, constraint: &'a AssocTyConstraint) {
         match constraint.kind {
             AssocTyConstraintKind::Equality { .. } => {}
@@ -795,20 +819,43 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     }
 
     fn visit_expr(&mut self, expr: &'a Expr) {
-        match &expr.kind {
-            ExprKind::LlvmInlineAsm(..) if !self.session.target.allow_asm => {
-                struct_span_err!(
-                    self.session,
-                    expr.span,
-                    E0472,
-                    "llvm_asm! is unsupported on this target"
-                )
-                .emit();
+        self.with_let_allowed(false, |this, let_allowed| {
+            match &expr.kind {
+                ExprKind::LlvmInlineAsm(..) if !this.session.target.allow_asm => {
+                    struct_span_err!(
+                        this.session,
+                        expr.span,
+                        E0472,
+                        "llvm_asm! is unsupported on this target"
+                    )
+                    .emit();
+                }
+                ExprKind::Let(..) if !let_allowed => this.ban_let_expr(expr),
+                // `(e)` or `e && e` does not impose additional constraints on `e`.
+                ExprKind::Paren(_) | ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ..) => {
+                    this.with_let_allowed(let_allowed, |this, _| visit::walk_expr(this, expr));
+                    return; // We've already walked into `expr`.
+                }
+                // However, we do allow it in the condition of the `if` expression.
+                // We do not allow `let` in `then` and `opt_else` directly.
+                ExprKind::If(cond, then, opt_else) => {
+                    this.visit_block(then);
+                    walk_list!(this, visit_expr, opt_else);
+                    this.with_let_allowed(true, |this, _| this.visit_expr(cond));
+                    return; // We've already walked into `expr`.
+                }
+                // The same logic applies to `While`.
+                ExprKind::While(cond, then, opt_label) => {
+                    walk_list!(this, visit_label, opt_label);
+                    this.visit_block(then);
+                    this.with_let_allowed(true, |this, _| this.visit_expr(cond));
+                    return; // We've already walked into `expr`.
+                }
+                _ => {}
             }
-            _ => {}
-        }
 
-        visit::walk_expr(self, expr);
+            visit::walk_expr(this, expr);
+        });
     }
 
     fn visit_ty(&mut self, ty: &'a Ty) {
@@ -1443,6 +1490,7 @@ pub fn check_crate(session: &Session, krate: &Crate, lints: &mut LintBuffer) ->
         bound_context: None,
         is_impl_trait_banned: false,
         is_assoc_ty_bound_banned: false,
+        is_let_allowed: false,
         lint_buffer: lints,
     };
     visit::walk_crate(&mut validator, krate);
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 3c28b48795f56..361d2ee7fb8c1 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1364,6 +1364,7 @@ impl Expr<'_> {
             ExprKind::Lit(_) => ExprPrecedence::Lit,
             ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast,
             ExprKind::DropTemps(ref expr, ..) => expr.precedence(),
+            ExprKind::Let(..) => ExprPrecedence::Let,
             ExprKind::Loop(..) => ExprPrecedence::Loop,
             ExprKind::Match(..) => ExprPrecedence::Match,
             ExprKind::Closure(..) => ExprPrecedence::Closure,
@@ -1433,6 +1434,7 @@ impl Expr<'_> {
             | ExprKind::Break(..)
             | ExprKind::Continue(..)
             | ExprKind::Ret(..)
+            | ExprKind::Let(..)
             | ExprKind::Loop(..)
             | ExprKind::Assign(..)
             | ExprKind::InlineAsm(..)
@@ -1541,6 +1543,11 @@ pub enum ExprKind<'hir> {
     /// This construct only exists to tweak the drop order in HIR lowering.
     /// An example of that is the desugaring of `for` loops.
     DropTemps(&'hir Expr<'hir>),
+    /// A `let $pat = $expr` expression.
+    ///
+    /// These are not `Local` which only occur as statements.
+    /// The `let Some(x) = foo()` in `if let Some(x) = foo()` is an example of `Let(..)`.
+    Let(&'hir Pat<'hir>, &'hir Expr<'hir>),
     /// A conditionless loop (can be exited with `break`, `continue`, or `return`).
     ///
     /// I.e., `'label: loop { <block> }`.
@@ -1696,13 +1703,8 @@ pub enum MatchSource {
     Normal,
     /// An `if _ { .. }` (optionally with `else { .. }`).
     IfDesugar { contains_else_clause: bool },
-    /// An `if let _ = _ { .. }` (optionally with `else { .. }`).
-    IfLetDesugar { contains_else_clause: bool },
     /// A `while _ { .. }` (which was desugared to a `loop { match _ { .. } }`).
     WhileDesugar,
-    /// A `while let _ = _ { .. }` (which was desugared to a
-    /// `loop { match _ { .. } }`).
-    WhileLetDesugar,
     /// A desugared `for _ in _ { .. }` loop.
     ForLoopDesugar,
     /// A desugared `?` operator.
@@ -1716,8 +1718,8 @@ impl MatchSource {
         use MatchSource::*;
         match self {
             Normal => "match",
-            IfDesugar { .. } | IfLetDesugar { .. } => "if",
-            WhileDesugar | WhileLetDesugar => "while",
+            IfDesugar { .. } => "if",
+            WhileDesugar => "while",
             ForLoopDesugar => "for",
             TryDesugar => "?",
             AwaitDesugar => ".await",
@@ -1732,8 +1734,6 @@ pub enum LoopSource {
     Loop,
     /// A `while _ { .. }` loop.
     While,
-    /// A `while let _ = _ { .. }` loop.
-    WhileLet,
     /// A `for _ in _ { .. }` loop.
     ForLoop,
 }
@@ -1742,7 +1742,7 @@ impl LoopSource {
     pub fn name(self) -> &'static str {
         match self {
             LoopSource::Loop => "loop",
-            LoopSource::While | LoopSource::WhileLet => "while",
+            LoopSource::While => "while",
             LoopSource::ForLoop => "for",
         }
     }
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 35615af0fc7df..4475f33c88627 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -484,8 +484,7 @@ pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &'v Body<'v>) {
 }
 
 pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local<'v>) {
-    // Intentionally visiting the expr first - the initialization expr
-    // dominates the local's definition.
+    // Visit the expr first. The initialization expr dominates the local's definition.
     walk_list!(visitor, visit_expr, &local.init);
     walk_list!(visitor, visit_attribute, local.attrs.iter());
     visitor.visit_id(local.hir_id);
@@ -1107,6 +1106,12 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
         ExprKind::DropTemps(ref subexpression) => {
             visitor.visit_expr(subexpression);
         }
+        ExprKind::Let(ref pat, ref expr) => {
+            // Visit the expr first. The initialization expr dominates the `let`'s definition.
+            // This is the same logic in `walk_local`.
+            visitor.visit_expr(expr);
+            visitor.visit_pat(pat);
+        }
         ExprKind::Loop(ref block, ref opt_label, _) => {
             walk_list!(visitor, visit_label, opt_label);
             visitor.visit_block(block);
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index f7018ae62aa19..42f86212272e8 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1094,28 +1094,44 @@ impl<'a> State<'a> {
         self.pclose()
     }
 
-    pub fn print_expr_maybe_paren(&mut self, expr: &hir::Expr<'_>, prec: i8) {
-        let needs_par = expr.precedence().order() < prec;
-        if needs_par {
-            self.popen();
-        }
-        self.print_expr(expr);
-        if needs_par {
-            self.pclose();
-        }
+    /// Print a `let pat = scrutinee` expression.
+    fn print_let(&mut self, pat: &hir::Pat<'_>, scrutinee: &hir::Expr<'_>) {
+        self.s.word("let ");
+
+        self.print_pat(pat);
+        self.s.space();
+
+        self.word_space("=");
+        self.print_expr_cond_paren(
+            scrutinee,
+            Self::cond_needs_par(scrutinee)
+                || parser::needs_par_as_let_scrutinee(scrutinee.precedence().order()),
+        )
     }
 
-    /// Print an expr using syntax that's acceptable in a condition position, such as the `cond` in
+    /// Prints an expr using syntax that's acceptable in a condition position, such as the `cond` in
     /// `if cond { ... }`.
-    pub fn print_expr_as_cond(&mut self, expr: &hir::Expr<'_>) {
-        let needs_par = match expr.kind {
+    fn print_expr_as_cond(&mut self, expr: &hir::Expr<'_>) {
+        self.print_expr_cond_paren(expr, Self::cond_needs_par(expr))
+    }
+
+    fn print_expr_maybe_paren(&mut self, expr: &hir::Expr<'_>, prec: i8) {
+        self.print_expr_cond_paren(expr, expr.precedence().order() < prec)
+    }
+
+    /// Does `expr` need parenthesis when printed in a condition position?
+    fn cond_needs_par(expr: &hir::Expr<'_>) -> bool {
+        match expr.kind {
             // These cases need parens due to the parse error observed in #26461: `if return {}`
             // parses as the erroneous construct `if (return {})`, not `if (return) {}`.
             hir::ExprKind::Closure(..) | hir::ExprKind::Ret(..) | hir::ExprKind::Break(..) => true,
 
             _ => contains_exterior_struct_lit(expr),
-        };
+        }
+    }
 
+    /// Prints `expr` or `(expr)` when `needs_par` holds.
+    fn print_expr_cond_paren(&mut self, expr: &hir::Expr<'_>, needs_par: bool) {
         if needs_par {
             self.popen();
         }
@@ -1243,6 +1259,9 @@ impl<'a> State<'a> {
             (&hir::ExprKind::Cast { .. }, hir::BinOpKind::Lt | hir::BinOpKind::Shl) => {
                 parser::PREC_FORCE_PAREN
             }
+            (&hir::ExprKind::Let { .. }, _) if !parser::needs_par_as_let_scrutinee(prec) => {
+                parser::PREC_FORCE_PAREN
+            }
             _ => left_prec,
         };
 
@@ -1353,6 +1372,9 @@ impl<'a> State<'a> {
                 // Print `}`:
                 self.bclose_maybe_open(expr.span, true);
             }
+            hir::ExprKind::Let(ref pat, ref scrutinee) => {
+                self.print_let(pat, scrutinee);
+            }
             hir::ExprKind::Loop(ref blk, opt_label, _) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index 524efd04cfce9..283e814952125 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -622,17 +622,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 scrut_span,
                 ..
             }) => match source {
-                hir::MatchSource::IfLetDesugar { .. } => {
-                    let msg = "`if let` arms have incompatible types";
-                    err.span_label(cause.span, msg);
-                    if let Some(ret_sp) = opt_suggest_box_span {
-                        self.suggest_boxing_for_return_impl_trait(
-                            err,
-                            ret_sp,
-                            prior_arms.iter().chain(std::iter::once(&arm_span)).map(|s| *s),
-                        );
-                    }
-                }
                 hir::MatchSource::TryDesugar => {
                     if let Some(ty::error::ExpectedFound { expected, .. }) = exp_found {
                         let scrut_expr = self.tcx.hir().expect_expr(scrut_hir_id);
@@ -2349,9 +2338,6 @@ impl<'tcx> ObligationCauseExt<'tcx> for ObligationCause<'tcx> {
             CompareImplTypeObligation { .. } => Error0308("type not compatible with trait"),
             MatchExpressionArm(box MatchExpressionArmCause { source, .. }) => {
                 Error0308(match source {
-                    hir::MatchSource::IfLetDesugar { .. } => {
-                        "`if let` arms have incompatible types"
-                    }
                     hir::MatchSource::TryDesugar => {
                         "try expression alternatives have incompatible types"
                     }
@@ -2387,10 +2373,7 @@ impl<'tcx> ObligationCauseExt<'tcx> for ObligationCause<'tcx> {
             CompareImplMethodObligation { .. } => "method type is compatible with trait",
             CompareImplTypeObligation { .. } => "associated type is compatible with trait",
             ExprAssignable => "expression is assignable",
-            MatchExpressionArm(box MatchExpressionArmCause { source, .. }) => match source {
-                hir::MatchSource::IfLetDesugar { .. } => "`if let` arms have compatible types",
-                _ => "`match` arms have compatible types",
-            },
+            MatchExpressionArm(_) => "`match` arms have compatible types",
             IfExpression { .. } => "`if` and `else` have incompatible types",
             IfExpressionWithNoElse => "`if` missing an `else` returns `()`",
             MainFunctionType => "`main` function has the correct type",
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 6ed7ed575fcb5..ed099c21aca19 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -536,8 +536,54 @@ fn make_mirror_unadjusted<'a, 'tcx>(
             },
             Err(err) => bug!("invalid loop id for continue: {}", err),
         },
-        hir::ExprKind::Match(ref discr, ref arms, _) => ExprKind::Match {
-            scrutinee: discr.to_ref(),
+        hir::ExprKind::Let(ref pat, ref scrutinee) => {
+            // HACK(let_chains, Centril): Temporary solution while we cannot lower these to MIR.
+            //
+            // If we got here, the `let` expression is not allowed
+            // and we have emitted an error in HIR lowering.
+            //
+            // For better recovery, we emit:
+            // ```
+            // match scrutinee { pat => true, _ => false }
+            // ```
+            // While this doesn't fully match the user's intent, it has key advantages:
+            // 1. We can avoid using `abort_if_errors`.
+            // 2. We can typeck both `pat` and `scrutinee`.
+            // 3. `pat` is allowed to be refutable.
+            // 4. The return type of the block is `bool` which seems like what the user wanted.
+            let span = expr.span;
+            let pat = cx.pattern_from_hir(pat);
+            let arm = |pattern, val| {
+                let literal = Const::from_bool(cx.tcx, val);
+                // FIXME(hlrb) const_id should not be None
+                let kind = ExprKind::Literal { literal, user_ty: None, const_id: None };
+                let body = Expr { temp_lifetime, ty: expr_ty, span, kind }.to_ref();
+                let scope =
+                    region::Scope { id: expr.hir_id.local_id, data: region::ScopeData::Node };
+                let lint_level = LintLevel::Inherited;
+                Arm { pattern, guard: None, body, lint_level, scope, span }
+            };
+            let else_arm = arm(Pat::wildcard_from_ty(pat.ty), false);
+            let then_arm = arm(pat, true);
+            ExprKind::Match { scrutinee: scrutinee.to_ref(), arms: vec![then_arm, else_arm] }
+        }
+        hir::ExprKind::Match(
+            hir::Expr { kind: hir::ExprKind::Let(ref pat, ref scrutinee), .. },
+            [ref then_arm, ref else_arm],
+            _,
+        ) => {
+            // HACK(let_chains, Centril): This is the desugaring for `if let`.
+            // We do not yet have `thir::ExprKind::Let`.
+            // Therefore, we lower: `match (let pat = scrutinee) { true => then, _ => elze }`,
+            // into: `match scrutinee { pat => then, _ => elze }`.
+            let mut then_arm = convert_arm(cx, then_arm);
+            let mut else_arm = convert_arm(cx, else_arm);
+            then_arm.pattern = cx.pattern_from_hir(pat);
+            else_arm.pattern = Pat::wildcard_from_ty(then_arm.pattern.ty);
+            ExprKind::Match { scrutinee: scrutinee.to_ref(), arms: vec![then_arm, else_arm] }
+        }
+        hir::ExprKind::Match(ref scrutinee, ref arms, _) => ExprKind::Match {
+            scrutinee: scrutinee.to_ref(),
             arms: arms.iter().map(|a| convert_arm(cx, a)).collect(),
         },
         hir::ExprKind::Loop(ref body, _, _) => {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 14ed93f112788..60501e9e9af43 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -55,9 +55,10 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
 
     fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
         intravisit::walk_expr(self, ex);
-
-        if let hir::ExprKind::Match(ref scrut, ref arms, source) = ex.kind {
-            self.check_match(scrut, arms, source);
+        match &ex.kind {
+            hir::ExprKind::Match(scrut, arms, source) => self.check_match(scrut, arms, *source),
+            hir::ExprKind::Let(pat, scrut) => self.check_let(pat, scrut),
+            _ => {}
         }
     }
 
@@ -72,13 +73,13 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
             hir::LocalSource::AssignDesugar(_) => ("destructuring assignment binding", None),
         };
         self.check_irrefutable(&loc.pat, msg, sp);
-        self.check_patterns(&loc.pat);
+        self.check_pattern(&loc.pat);
     }
 
     fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
         intravisit::walk_param(self, param);
         self.check_irrefutable(&param.pat, "function argument", None);
-        self.check_patterns(&param.pat);
+        self.check_pattern(&param.pat);
     }
 }
 
@@ -120,7 +121,7 @@ impl PatCtxt<'_, '_> {
 }
 
 impl<'tcx> MatchVisitor<'_, 'tcx> {
-    fn check_patterns(&mut self, pat: &Pat<'_>) {
+    fn check_pattern(&mut self, pat: &Pat<'_>) {
         pat.walk_always(|pat| check_borrow_conflicts_in_at_patterns(self, pat));
         if !self.tcx.features().bindings_after_at {
             check_legality_of_bindings_in_at_patterns(self, pat);
@@ -155,6 +156,37 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
         }
     }
 
+    fn check_let(&mut self, pat: &'tcx hir::Pat<'tcx>, scrut: &hir::Expr<'_>) {
+        self.check_pattern(pat);
+
+        let mut cx = self.new_cx(scrut.hir_id);
+
+        // This does *not* perform exhaustiveness checking, as it is not required for soundness.
+        // Lower the pattern. Note that `lower_pattern` performs some static analysis
+        // which may result in errors. As such, this cannot be removed.
+        let mut have_errors = false;
+        let pattern = self.lower_pattern(&mut cx, pat, &mut have_errors).0;
+        if have_errors {
+            return;
+        }
+
+        let tcx = cx.tcx;
+        let id = pat.hir_id;
+        let mut seen = Matrix::empty();
+        // Lint the branch with the user-specified pattern.
+        let v = PatStack::from_pattern(&pattern);
+        check_useful_lint(&mut cx, &seen, &v, id, false, || {
+            unreachable_pattern(tcx, pat.span, id, None)
+        });
+        seen.push(v);
+        // Lint the logical fallback branch.
+        let wild = cx.pattern_arena.alloc(super::Pat::wildcard_from_ty(pattern.ty));
+        wild.span = pattern.span;
+        check_useful_lint(&mut cx, &seen, &PatStack::from_pattern(wild), id, false, || {
+            irrefutable_let_pattern(tcx, pat.span, id);
+        });
+    }
+
     fn check_match(
         &mut self,
         scrut: &hir::Expr<'_>,
@@ -163,7 +195,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
     ) {
         for arm in arms {
             // Check the arm for some things unrelated to exhaustiveness.
-            self.check_patterns(&arm.pat);
+            self.check_pattern(&arm.pat);
         }
 
         let mut cx = self.new_cx(scrut.hir_id);
@@ -344,62 +376,59 @@ fn unreachable_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, catchall: Option<
     });
 }
 
-fn irrefutable_let_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, source: hir::MatchSource) {
+fn irrefutable_let_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId) {
     tcx.struct_span_lint_hir(IRREFUTABLE_LET_PATTERNS, id, span, |lint| {
-        let msg = match source {
-            hir::MatchSource::IfLetDesugar { .. } => "irrefutable if-let pattern",
-            hir::MatchSource::WhileLetDesugar => "irrefutable while-let pattern",
-            _ => bug!(),
-        };
-        lint.build(msg).emit()
+        lint.build("irrefutable `let` pattern").emit()
     });
 }
 
-/// Check for unreachable patterns.
+/// Lint on unreachable patterns and delegate to `handle()` for the useless case.
+fn check_useful_lint<'p, 'tcx>(
+    cx: &mut MatchCheckCtxt<'p, 'tcx>,
+    matrix: &Matrix<'p, 'tcx>,
+    v: &PatStack<'p, 'tcx>,
+    hir_id: HirId,
+    has_guard: bool,
+    handle: impl FnOnce(),
+) {
+    match is_useful(cx, &matrix, &v, LeaveOutWitness, hir_id, has_guard, true) {
+        NotUseful => handle(),
+        Useful(unreachables) => {
+            let mut unreachables: Vec<_> = unreachables.into_iter().flatten().collect();
+            // Emit lints in the order in which they occur in the file.
+            unreachables.sort_unstable();
+            for span in unreachables {
+                unreachable_pattern(cx.tcx, span, hir_id, None);
+            }
+        }
+        UsefulWithWitness(_) => bug!(),
+    }
+}
+
+/// Check for unreachable patterns in `match` and build up the matrix for exhaustiveness checking.
 fn check_arms<'p, 'tcx>(
     cx: &mut MatchCheckCtxt<'p, 'tcx>,
     arms: &[(&'p super::Pat<'tcx>, HirId, bool)],
     source: hir::MatchSource,
 ) -> Matrix<'p, 'tcx> {
+    let tcx = cx.tcx;
     let mut seen = Matrix::empty();
     let mut catchall = None;
-    for (arm_index, (pat, id, has_guard)) in arms.iter().copied().enumerate() {
+    for (pat, id, has_guard) in arms.iter().copied() {
         let v = PatStack::from_pattern(pat);
-        match is_useful(cx, &seen, &v, LeaveOutWitness, id, has_guard, true) {
-            NotUseful => {
-                match source {
-                    hir::MatchSource::IfDesugar { .. } | hir::MatchSource::WhileDesugar => bug!(),
-
-                    hir::MatchSource::IfLetDesugar { .. } | hir::MatchSource::WhileLetDesugar => {
-                        // Check which arm we're on.
-                        match arm_index {
-                            // The arm with the user-specified pattern.
-                            0 => unreachable_pattern(cx.tcx, pat.span, id, None),
-                            // The arm with the wildcard pattern.
-                            1 => irrefutable_let_pattern(cx.tcx, pat.span, id, source),
-                            _ => bug!(),
-                        }
-                    }
-
-                    hir::MatchSource::ForLoopDesugar | hir::MatchSource::Normal => {
-                        unreachable_pattern(cx.tcx, pat.span, id, catchall);
-                    }
+        check_useful_lint(cx, &seen, &v, id, has_guard, || {
+            match source {
+                hir::MatchSource::IfDesugar { .. } | hir::MatchSource::WhileDesugar => bug!(),
 
-                    // Unreachable patterns in try and await expressions occur when one of
-                    // the arms are an uninhabited type. Which is OK.
-                    hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar => {}
-                }
-            }
-            Useful(unreachables) => {
-                let mut unreachables: Vec<_> = unreachables.into_iter().flatten().collect();
-                // Emit lints in the order in which they occur in the file.
-                unreachables.sort_unstable();
-                for span in unreachables {
-                    unreachable_pattern(cx.tcx, span, id, None);
+                hir::MatchSource::ForLoopDesugar | hir::MatchSource::Normal => {
+                    unreachable_pattern(tcx, pat.span, id, catchall);
                 }
+
+                // Unreachable patterns in try and await expressions occur when one of
+                // the arms are an uninhabited type. Which is OK.
+                hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar => {}
             }
-            UsefulWithWitness(_) => bug!(),
-        }
+        });
         if !has_guard {
             seen.push(v);
             if catchall.is_none() && pat_is_catchall(pat) {
diff --git a/compiler/rustc_passes/src/check_const.rs b/compiler/rustc_passes/src/check_const.rs
index b24c62b971a46..6b5a3b2e07849 100644
--- a/compiler/rustc_passes/src/check_const.rs
+++ b/compiler/rustc_passes/src/check_const.rs
@@ -47,10 +47,7 @@ impl NonConstExpr {
             }
 
             // All other expressions are allowed.
-            Self::Loop(Loop | While | WhileLet)
-            | Self::Match(
-                WhileDesugar | WhileLetDesugar | Normal | IfDesugar { .. } | IfLetDesugar { .. },
-            ) => &[],
+            Self::Loop(Loop | While) | Self::Match(WhileDesugar | Normal | IfDesugar { .. }) => &[],
         };
 
         Some(gates)
@@ -207,10 +204,7 @@ impl<'tcx> Visitor<'tcx> for CheckConstVisitor<'tcx> {
             hir::ExprKind::Match(_, _, source) => {
                 let non_const_expr = match source {
                     // These are handled by `ExprKind::Loop` above.
-                    hir::MatchSource::WhileDesugar
-                    | hir::MatchSource::WhileLetDesugar
-                    | hir::MatchSource::ForLoopDesugar => None,
-
+                    hir::MatchSource::WhileDesugar | hir::MatchSource::ForLoopDesugar => None,
                     _ => Some(NonConstExpr::Match(*source)),
                 };
 
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 7288015e17029..32f8d286470a0 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -407,6 +407,10 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
                 intravisit::walk_expr(self, expr);
             }
 
+            hir::ExprKind::Let(ref pat, _) => {
+                self.add_from_pat(pat);
+                intravisit::walk_expr(self, expr);
+            }
             // live nodes required for interesting control flow:
             hir::ExprKind::Match(..) | hir::ExprKind::Loop(..) => {
                 self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
@@ -993,6 +997,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 })
             }
 
+            hir::ExprKind::Let(ref pat, ref scrutinee) => {
+                let succ = self.propagate_through_expr(scrutinee, succ);
+                self.define_bindings_in_pat(pat, succ)
+            }
+
             // Note that labels have been resolved, so we don't need to look
             // at the label ident
             hir::ExprKind::Loop(ref blk, _, _) => self.propagate_through_loop(expr, &blk, succ),
@@ -1406,8 +1415,9 @@ impl<'a, 'tcx> Visitor<'tcx> for Liveness<'a, 'tcx> {
         intravisit::walk_local(self, local);
     }
 
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        check_expr(self, ex);
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        check_expr(self, expr);
+        intravisit::walk_expr(self, expr);
     }
 
     fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
@@ -1463,6 +1473,10 @@ fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr<'tcx>) {
             }
         }
 
+        hir::ExprKind::Let(ref pat, _) => {
+            this.check_unused_vars_in_pat(pat, None, |_, _, _, _| {});
+        }
+
         // no correctness conditions related to liveness
         hir::ExprKind::Call(..)
         | hir::ExprKind::MethodCall(..)
@@ -1492,8 +1506,6 @@ fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr<'tcx>) {
         | hir::ExprKind::Type(..)
         | hir::ExprKind::Err => {}
     }
-
-    intravisit::walk_expr(this, expr);
 }
 
 impl<'tcx> Liveness<'_, 'tcx> {
diff --git a/compiler/rustc_passes/src/region.rs b/compiler/rustc_passes/src/region.rs
index 1af79abe4b911..646050bacc303 100644
--- a/compiler/rustc_passes/src/region.rs
+++ b/compiler/rustc_passes/src/region.rs
@@ -158,7 +158,11 @@ fn resolve_block<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, blk: &'tcx h
     visitor.cx = prev_cx;
 }
 
-fn resolve_arm<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, arm: &'tcx hir::Arm<'tcx>) {
+fn resolve_arm<'tcx>(
+    visitor: &mut RegionResolutionVisitor<'tcx>,
+    arm: &'tcx hir::Arm<'tcx>,
+    hack_for_let: impl FnOnce(&mut RegionResolutionVisitor<'tcx>),
+) {
     let prev_cx = visitor.cx;
 
     visitor.enter_scope(Scope { id: arm.hir_id.local_id, data: ScopeData::Node });
@@ -170,7 +174,11 @@ fn resolve_arm<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, arm: &'tcx hir
         visitor.terminating_scopes.insert(expr.hir_id.local_id);
     }
 
-    intravisit::walk_arm(visitor, arm);
+    // HACK(let_chains, Centril): See `resolve_expr` below wrt. `::Let`.
+    // The goal here is to visit the `pat` in `let pat = _` as-if it were part of the `arm`.
+    hack_for_let(visitor);
+    // HACK(let_chains, Centril: Restore to the following when we can!
+    //intravisit::walk_arm(visitor, arm);
 
     visitor.cx = prev_cx;
 }
@@ -389,6 +397,28 @@ fn resolve_expr<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, expr: &'tcx h
             }
         }
 
+        hir::ExprKind::Match(
+            hir::Expr { kind: hir::ExprKind::Let(ref pat, scrutinee), .. },
+            [ref then_arm, ref else_arm],
+            _,
+        ) => {
+            // HACK(let_chains, Centril): In HAIR lowering we currently adjust this
+            // to `match scrutinee { pat => then_arm.body, _ => else_arm.body }`.
+            // For consistency, we have to adjust the scopes here as well wrt. `pat`.
+            // Moreover, we need to replicate the visiting order in
+            // `intravisit::walk_expr` with respect to `ExprKind::Match`.
+            visitor.visit_expr(scrutinee);
+            // This is for the `then_arm`. NOTE(Centril): Preserve the order in `intravisit`!
+            resolve_arm(visitor, then_arm, |visitor| {
+                visitor.visit_id(then_arm.hir_id);
+                // NOTE(Centril): We are using `pat` here as opposed to `then_arm.pat`!
+                visitor.visit_pat(pat);
+                assert!(then_arm.guard.is_none());
+                visitor.visit_expr(&then_arm.body);
+                walk_list!(visitor, visit_attribute, then_arm.attrs);
+            });
+            visitor.visit_arm(else_arm);
+        }
         _ => intravisit::walk_expr(visitor, expr),
     }
 
@@ -785,7 +815,7 @@ impl<'tcx> Visitor<'tcx> for RegionResolutionVisitor<'tcx> {
     }
 
     fn visit_arm(&mut self, a: &'tcx Arm<'tcx>) {
-        resolve_arm(self, a);
+        resolve_arm(self, a, |this| intravisit::walk_arm(this, a));
     }
     fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
         resolve_pat(self, p);
diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs
index e8eea65137ff7..99a7e54eca08f 100644
--- a/compiler/rustc_typeck/src/check/_match.rs
+++ b/compiler/rustc_typeck/src/check/_match.rs
@@ -26,7 +26,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         use hir::MatchSource::*;
         let (source_if, if_no_else, force_scrutinee_bool) = match match_src {
             IfDesugar { contains_else_clause } => (true, !contains_else_clause, true),
-            IfLetDesugar { contains_else_clause, .. } => (true, !contains_else_clause, false),
             WhileDesugar => (false, false, true),
             _ => (false, false, false),
         };
@@ -43,7 +42,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // FIXME(60707): Consider removing hack with principled solution.
             self.check_expr_has_type_or_error(scrut, self.tcx.types.bool, |_| {})
         } else {
-            self.demand_scrutinee_type(arms, scrut)
+            self.demand_scrutinee_type(arms.iter().map(|a| a.pat), scrut)
         };
 
         // If there are no arms, that is a diverging match; a special case.
@@ -269,10 +268,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         arms: &'tcx [hir::Arm<'tcx>],
         source: hir::MatchSource,
     ) {
-        use hir::MatchSource::*;
         let msg = match source {
-            IfDesugar { .. } | IfLetDesugar { .. } => "block in `if` expression",
-            WhileDesugar { .. } | WhileLetDesugar { .. } => "block in `while` expression",
+            hir::MatchSource::IfDesugar { .. } => "block in `if` expression",
+            hir::MatchSource::WhileDesugar { .. } => "block in `while` expression",
             _ => "arm",
         };
         for arm in arms {
@@ -448,9 +446,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         )
     }
 
-    fn demand_scrutinee_type(
+    pub(super) fn demand_scrutinee_type(
         &self,
-        arms: &'tcx [hir::Arm<'tcx>],
+        pats: impl Iterator<Item = &'tcx hir::Pat<'tcx>> + ExactSizeIterator,
         scrut: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
         // Not entirely obvious: if matches may create ref bindings, we want to
@@ -505,17 +503,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // (once introduced) is populated by the time we get here.
         //
         // See #44848.
-        let contains_ref_bindings = arms
-            .iter()
-            .filter_map(|a| a.pat.contains_explicit_ref_binding())
-            .max_by_key(|m| match *m {
+        let pats_empty = pats.len() == 0;
+        let contains_ref_bindings =
+            pats.filter_map(|p| p.contains_explicit_ref_binding()).max_by_key(|m| match *m {
                 hir::Mutability::Mut => 1,
                 hir::Mutability::Not => 0,
             });
 
         if let Some(m) = contains_ref_bindings {
             self.check_expr_with_needs(scrut, Needs::maybe_mut_place(m))
-        } else if arms.is_empty() {
+        } else if pats_empty {
             self.check_expr(scrut)
         } else {
             // ...but otherwise we want to use any supertype of the
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
index af19ad08c1d08..1137afa0df790 100644
--- a/compiler/rustc_typeck/src/check/expr.rs
+++ b/compiler/rustc_typeck/src/check/expr.rs
@@ -264,11 +264,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
+            ExprKind::Let(ref pat, ref scrutinee) => self.check_expr_let(pat, scrutinee),
             ExprKind::Loop(ref body, _, source) => {
                 self.check_expr_loop(body, source, expected, expr)
             }
-            ExprKind::Match(ref discrim, ref arms, match_src) => {
-                self.check_match(expr, &discrim, arms, expected, match_src)
+            ExprKind::Match(ref scrutinee, ref arms, match_src) => {
+                self.check_match(expr, &scrutinee, arms, expected, match_src)
             }
             ExprKind::Closure(capture, ref decl, body_id, _, gen) => {
                 self.check_expr_closure(expr, capture, &decl, body_id, gen, expected)
@@ -816,6 +817,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    fn check_expr_let(&self, pat: &'tcx hir::Pat<'tcx>, scrut: &'tcx hir::Expr<'tcx>) -> Ty<'tcx> {
+        let scrut_ty = self.demand_scrutinee_type(core::iter::once(pat), scrut);
+        self.check_pat_top(pat, scrut_ty, Some(scrut.span), true);
+        self.tcx.types.bool
+    }
+
     fn check_expr_loop(
         &self,
         body: &'tcx hir::Block<'tcx>,
@@ -829,8 +836,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let coerce_to = expected.coercion_target_type(self, body.span);
                 Some(CoerceMany::new(coerce_to))
             }
-
-            hir::LoopSource::While | hir::LoopSource::WhileLet | hir::LoopSource::ForLoop => None,
+            hir::LoopSource::While | hir::LoopSource::ForLoop => None,
         };
 
         let ctxt = BreakableCtxt {
diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs
index 293a995887c26..9c01b12318679 100644
--- a/compiler/rustc_typeck/src/check/generator_interior.rs
+++ b/compiler/rustc_typeck/src/check/generator_interior.rs
@@ -307,6 +307,25 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> {
                     _ => {}
                 }
             }
+            ExprKind::Match(
+                Expr { kind: ExprKind::Let(pat, scrutinee), .. },
+                [then_arm, else_arm],
+                _,
+            ) => {
+                // HACK(let_chains, Centril): In HAIR lowering we currently adjust this
+                // to `match scrutinee { pat => then_arm.body, _ => else_arm.body }`.
+                // For consistency, we need to replicate the visiting order in
+                // `intravisit::walk_expr` with respect to `ExprKind::Match`.
+                self.visit_expr(scrutinee);
+                // This is for the `then_arm`. NOTE(Centril): Preserve the order in `intravisit`!
+                self.visit_id(then_arm.hir_id);
+                // NOTE(Centril): We are using `pat` here as opposed to `then_arm.pat`!
+                self.visit_pat(pat);
+                assert!(then_arm.guard.is_none());
+                self.visit_expr(&then_arm.body);
+                rustc_ast::walk_list!(self, visit_attribute, then_arm.attrs);
+                self.visit_arm(else_arm);
+            }
             _ => intravisit::walk_expr(self, expr),
         }
 
diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs
index 57bd89b9d3da9..6ddd88887fa07 100644
--- a/compiler/rustc_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_typeck/src/expr_use_visitor.rs
@@ -123,7 +123,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
 
             let param_place = self.mc.cat_rvalue(param.hir_id, param.pat.span, param_ty);
 
-            self.walk_irrefutable_pat(&param_place, &param.pat);
+            self.walk_pat(&param_place, &param.pat);
         }
 
         self.consume_expr(&body.value);
@@ -218,13 +218,17 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                 self.consume_exprs(exprs);
             }
 
-            hir::ExprKind::Match(ref discr, arms, _) => {
-                let discr_place = return_if_err!(self.mc.cat_expr(&discr));
-                self.borrow_expr(&discr, ty::ImmBorrow);
+            hir::ExprKind::Let(ref pat, ref scrutinee) => {
+                self.walk_local(scrutinee, pat);
+            }
+
+            hir::ExprKind::Match(ref scrutinee, arms, _) => {
+                let scrut_place = return_if_err!(self.mc.cat_expr(&scrutinee));
+                self.borrow_expr(&scrutinee, ty::ImmBorrow);
 
-                // treatment of the discriminant is handled while walking the arms.
+                // Treatment of the scrutinee is handled while walking the arms.
                 for arm in arms {
-                    self.walk_arm(&discr_place, arm);
+                    self.walk_arm(&scrut_place, arm);
                 }
             }
 
@@ -344,10 +348,11 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
     }
 
     fn walk_stmt(&mut self, stmt: &hir::Stmt<'_>) {
-        match stmt.kind {
-            hir::StmtKind::Local(ref local) => {
-                self.walk_local(&local);
+        match &stmt.kind {
+            hir::StmtKind::Local(hir::Local { pat, init: Some(scrutinee), .. }) => {
+                self.walk_local(scrutinee, pat);
             }
+            hir::StmtKind::Local(_) => {}
 
             hir::StmtKind::Item(_) => {
                 // We don't visit nested items in this visitor,
@@ -360,16 +365,12 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
         }
     }
 
-    fn walk_local(&mut self, local: &hir::Local<'_>) {
-        if let Some(ref expr) = local.init {
-            // Variable declarations with
-            // initializers are considered
-            // "assigns", which is handled by
-            // `walk_pat`:
-            self.walk_expr(&expr);
-            let init_place = return_if_err!(self.mc.cat_expr(&expr));
-            self.walk_irrefutable_pat(&init_place, &local.pat);
-        }
+    fn walk_local(&mut self, scrutinee: &hir::Expr<'_>, pat: &hir::Pat<'_>) {
+        // Variable declarations with initializers are considered
+        // "assigns", which is handled by `walk_pat`:
+        self.walk_expr(&scrutinee);
+        let scrut_place = return_if_err!(self.mc.cat_expr(&scrutinee));
+        self.walk_pat(&scrut_place, &pat);
     }
 
     /// Indicates that the value of `blk` will be consumed, meaning either copied or moved
@@ -508,8 +509,8 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
         }
     }
 
-    fn walk_arm(&mut self, discr_place: &PlaceWithHirId<'tcx>, arm: &hir::Arm<'_>) {
-        self.walk_pat(discr_place, &arm.pat);
+    fn walk_arm(&mut self, scrut_place: &PlaceWithHirId<'tcx>, arm: &hir::Arm<'_>) {
+        self.walk_pat(scrut_place, &arm.pat);
 
         if let Some(hir::Guard::If(ref e)) = arm.guard {
             self.consume_expr(e)
@@ -518,19 +519,13 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
         self.consume_expr(&arm.body);
     }
 
-    /// Walks a pat that occurs in isolation (i.e., top-level of fn argument or
-    /// let binding, and *not* a match arm or nested pat.)
-    fn walk_irrefutable_pat(&mut self, discr_place: &PlaceWithHirId<'tcx>, pat: &hir::Pat<'_>) {
-        self.walk_pat(discr_place, pat);
-    }
-
     /// The core driver for walking a pattern
-    fn walk_pat(&mut self, discr_place: &PlaceWithHirId<'tcx>, pat: &hir::Pat<'_>) {
-        debug!("walk_pat(discr_place={:?}, pat={:?})", discr_place, pat);
+    fn walk_pat(&mut self, scrut_place: &PlaceWithHirId<'tcx>, pat: &hir::Pat<'_>) {
+        debug!("walk_pat(scrut_place={:?}, pat={:?})", scrut_place, pat);
 
         let tcx = self.tcx();
         let ExprUseVisitor { ref mc, ref mut delegate } = *self;
-        return_if_err!(mc.cat_pattern(discr_place.clone(), pat, |place, pat| {
+        return_if_err!(mc.cat_pattern(scrut_place.clone(), pat, |place, pat| {
             if let PatKind::Binding(_, canonical_id, ..) = pat.kind {
                 debug!("walk_pat: binding place={:?} pat={:?}", place, pat,);
                 if let Some(bm) =
@@ -552,16 +547,16 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                     // It is also a borrow or copy/move of the value being matched.
                     // In a cases of pattern like `let pat = upvar`, don't use the span
                     // of the pattern, as this just looks confusing, instead use the span
-                    // of the discriminant.
+                    // of the scrutinee.
                     match bm {
                         ty::BindByReference(m) => {
                             let bk = ty::BorrowKind::from_mutbl(m);
-                            delegate.borrow(place, discr_place.hir_id, bk);
+                            delegate.borrow(place, scrut_place.hir_id, bk);
                         }
                         ty::BindByValue(..) => {
                             let mode = copy_or_move(mc, &place);
                             debug!("walk_pat binding consuming pat");
-                            delegate.consume(place, discr_place.hir_id, mode);
+                            delegate.consume(place, scrut_place.hir_id, mode);
                         }
                     }
                 }
diff --git a/compiler/rustc_typeck/src/mem_categorization.rs b/compiler/rustc_typeck/src/mem_categorization.rs
index f6ac7aa9155fe..3dfda21646f1b 100644
--- a/compiler/rustc_typeck/src/mem_categorization.rs
+++ b/compiler/rustc_typeck/src/mem_categorization.rs
@@ -367,6 +367,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
             | hir::ExprKind::Tup(..)
             | hir::ExprKind::Binary(..)
             | hir::ExprKind::Block(..)
+            | hir::ExprKind::Let(..)
             | hir::ExprKind::Loop(..)
             | hir::ExprKind::Match(..)
             | hir::ExprKind::Lit(..)
diff --git a/src/test/ui/if/if-let.rs b/src/test/ui/if/if-let.rs
index 2ab0f9fed3fc6..b4d8a559f4eca 100644
--- a/src/test/ui/if/if-let.rs
+++ b/src/test/ui/if/if-let.rs
@@ -4,30 +4,30 @@ fn macros() {
     macro_rules! foo{
         ($p:pat, $e:expr, $b:block) => {{
             if let $p = $e $b
-            //~^ WARN irrefutable if-let
-            //~| WARN irrefutable if-let
         }}
     }
-    macro_rules! bar{
-        ($p:pat, $e:expr, $b:block) => {{
-            foo!($p, $e, $b)
-        }}
+    macro_rules! bar {
+        ($p:pat, $e:expr, $b:block) => {{ foo!($p, $e, $b) }};
     }
 
     foo!(a, 1, {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     });
     bar!(a, 1, {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     });
 }
 
 pub fn main() {
-    if let a = 1 { //~ WARN irrefutable if-let
+    if let a = 1 {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     }
 
-    if let a = 1 { //~ WARN irrefutable if-let
+    if let a = 1 {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     } else if true {
         println!("else-if in irrefutable if-let");
@@ -37,13 +37,15 @@ pub fn main() {
 
     if let 1 = 2 {
         println!("refutable pattern");
-    } else if let a = 1 { //~ WARN irrefutable if-let
+    } else if let a = 1 {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     }
 
     if true {
         println!("if");
-    } else if let a = 1 { //~ WARN irrefutable if-let
+    } else if let a = 1 {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     }
 }
diff --git a/src/test/ui/if/if-let.stderr b/src/test/ui/if/if-let.stderr
index ee2b78af3b84d..2fbc235957365 100644
--- a/src/test/ui/if/if-let.stderr
+++ b/src/test/ui/if/if-let.stderr
@@ -1,19 +1,14 @@
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:6:13
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:13:10
    |
-LL |               if let $p = $e $b
-   |               ^^^^^^^^^^^^^^^^^
-...
-LL | /     foo!(a, 1, {
-LL | |         println!("irrefutable pattern");
-LL | |     });
-   | |_______- in this macro invocation
+LL |     foo!(a, 1, {
+   |          ^
    |
    = note: `#[warn(irrefutable_let_patterns)]` on by default
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:6:13
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:17:10
    |
 LL |               if let $p = $e $b
    |               ^^^^^^^^^^^^^^^^^
@@ -25,43 +20,29 @@ LL | |     });
    |
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:26:5
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:24:12
    |
-LL | /     if let a = 1 {
-LL | |         println!("irrefutable pattern");
-LL | |     }
-   | |_____^
+LL |     if let a = 1 {
+   |            ^
 
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:30:5
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:29:12
    |
-LL | /     if let a = 1 {
-LL | |         println!("irrefutable pattern");
-LL | |     } else if true {
-LL | |         println!("else-if in irrefutable if-let");
-LL | |     } else {
-LL | |         println!("else in irrefutable if-let");
-LL | |     }
-   | |_____^
+LL |     if let a = 1 {
+   |            ^
 
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:40:12
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:40:19
    |
-LL |       } else if let a = 1 {
-   |  ____________^
-LL | |         println!("irrefutable pattern");
-LL | |     }
-   | |_____^
+LL |     } else if let a = 1 {
+   |                   ^
 
-warning: irrefutable if-let pattern
-  --> $DIR/if-let.rs:46:12
+warning: irrefutable `let` pattern
+  --> $DIR/if-let.rs:47:19
    |
-LL |       } else if let a = 1 {
-   |  ____________^
-LL | |         println!("irrefutable pattern");
-LL | |     }
-   | |_____^
+LL |     } else if let a = 1 {
+   |                   ^
 
 warning: 6 warnings emitted
 
diff --git a/src/test/ui/pattern/deny-irrefutable-let-patterns.rs b/src/test/ui/pattern/deny-irrefutable-let-patterns.rs
index 14040c8ada67d..2e7b5b7ff3f7c 100644
--- a/src/test/ui/pattern/deny-irrefutable-let-patterns.rs
+++ b/src/test/ui/pattern/deny-irrefutable-let-patterns.rs
@@ -1,9 +1,10 @@
 #![deny(irrefutable_let_patterns)]
 
 fn main() {
-    if let _ = 5 {} //~ ERROR irrefutable if-let pattern
+    if let _ = 5 {} //~ ERROR irrefutable `let` pattern
 
-    while let _ = 5 { //~ ERROR irrefutable while-let pattern
+    while let _ = 5 {
+        //~^ ERROR irrefutable `let` pattern
         break;
     }
 }
diff --git a/src/test/ui/pattern/deny-irrefutable-let-patterns.stderr b/src/test/ui/pattern/deny-irrefutable-let-patterns.stderr
index 308a6c7c58e66..75faae0fd2427 100644
--- a/src/test/ui/pattern/deny-irrefutable-let-patterns.stderr
+++ b/src/test/ui/pattern/deny-irrefutable-let-patterns.stderr
@@ -1,8 +1,8 @@
-error: irrefutable if-let pattern
-  --> $DIR/deny-irrefutable-let-patterns.rs:4:5
+error: irrefutable `let` pattern
+  --> $DIR/deny-irrefutable-let-patterns.rs:4:12
    |
 LL |     if let _ = 5 {}
-   |     ^^^^^^^^^^^^^^^
+   |            ^
    |
 note: the lint level is defined here
   --> $DIR/deny-irrefutable-let-patterns.rs:1:9
@@ -10,13 +10,11 @@ note: the lint level is defined here
 LL | #![deny(irrefutable_let_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: irrefutable while-let pattern
-  --> $DIR/deny-irrefutable-let-patterns.rs:6:5
+error: irrefutable `let` pattern
+  --> $DIR/deny-irrefutable-let-patterns.rs:6:15
    |
-LL | /     while let _ = 5 {
-LL | |         break;
-LL | |     }
-   | |_____^
+LL |     while let _ = 5 {
+   |               ^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs b/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs
index f5cb1860d4786..fe02d2981b956 100644
--- a/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs
+++ b/src/test/ui/rfc-2497-if-let-chains/feature-gate.rs
@@ -13,33 +13,25 @@ fn _if() {
 
     if (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if (((let 0 = 1))) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if true && let 0 = 1 {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if let 0 = 1 && true {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if (let 0 = 1) && true {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if true && (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     if (let 0 = 1) && (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
 
     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
@@ -47,15 +39,9 @@ fn _if() {
     //~| ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
 
     if let Range { start: _, end: _ } = (true..true) && false {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 }
 
 fn _while() {
@@ -63,33 +49,25 @@ fn _while() {
 
     while (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while (((let 0 = 1))) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while true && let 0 = 1 {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while let 0 = 1 && true {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while (let 0 = 1) && true {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while true && (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 
     while (let 0 = 1) && (let 0 = 1) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
 
     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
@@ -97,19 +75,15 @@ fn _while() {
     //~| ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
     //~| ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
 
     while let Range { start: _, end: _ } = (true..true) && false {}
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
 }
 
 fn _macros() {
-    macro_rules! noop_expr { ($e:expr) => {}; }
+    macro_rules! noop_expr {
+        ($e:expr) => {};
+    }
 
     noop_expr!((let 0 = 1));
     //~^ ERROR `let` expressions in this position are experimental [E0658]
@@ -118,16 +92,12 @@ fn _macros() {
         ($e:expr) => {
             if $e {}
             while $e {}
-        }
+        };
     }
     use_expr!((let 0 = 1 && 0 == 0));
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
     use_expr!((let 0 = 1));
     //~^ ERROR `let` expressions in this position are experimental [E0658]
-    //~| ERROR `let` expressions are not supported here
-    //~| ERROR `let` expressions are not supported here
     #[cfg(FALSE)] (let 0 = 1);
     //~^ ERROR `let` expressions in this position are experimental [E0658]
     use_expr!(let 0 = 1);
diff --git a/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr b/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr
index 178e86272877d..fc8d1473ca3bb 100644
--- a/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr
+++ b/src/test/ui/rfc-2497-if-let-chains/feature-gate.stderr
@@ -1,5 +1,5 @@
 error: no rules expected the token `let`
-  --> $DIR/feature-gate.rs:133:15
+  --> $DIR/feature-gate.rs:103:15
    |
 LL |     macro_rules! use_expr {
    |     --------------------- when calling this macro
@@ -17,7 +17,7 @@ LL |     if (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:18:11
+  --> $DIR/feature-gate.rs:17:11
    |
 LL |     if (((let 0 = 1))) {}
    |           ^^^^^^^^^
@@ -26,7 +26,7 @@ LL |     if (((let 0 = 1))) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:22:16
+  --> $DIR/feature-gate.rs:20:16
    |
 LL |     if true && let 0 = 1 {}
    |                ^^^^^^^^^
@@ -35,7 +35,7 @@ LL |     if true && let 0 = 1 {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:26:8
+  --> $DIR/feature-gate.rs:23:8
    |
 LL |     if let 0 = 1 && true {}
    |        ^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     if let 0 = 1 && true {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:30:9
+  --> $DIR/feature-gate.rs:26:9
    |
 LL |     if (let 0 = 1) && true {}
    |         ^^^^^^^^^
@@ -53,7 +53,7 @@ LL |     if (let 0 = 1) && true {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:34:17
+  --> $DIR/feature-gate.rs:29:17
    |
 LL |     if true && (let 0 = 1) {}
    |                 ^^^^^^^^^
@@ -62,7 +62,7 @@ LL |     if true && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:38:9
+  --> $DIR/feature-gate.rs:32:9
    |
 LL |     if (let 0 = 1) && (let 0 = 1) {}
    |         ^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     if (let 0 = 1) && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:38:24
+  --> $DIR/feature-gate.rs:32:24
    |
 LL |     if (let 0 = 1) && (let 0 = 1) {}
    |                        ^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     if (let 0 = 1) && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:44:8
+  --> $DIR/feature-gate.rs:36:8
    |
 LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |        ^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:44:21
+  --> $DIR/feature-gate.rs:36:21
    |
 LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                     ^^^^^^^^^
@@ -98,7 +98,7 @@ LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:44:35
+  --> $DIR/feature-gate.rs:36:35
    |
 LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                   ^^^^^^^^^
@@ -107,7 +107,7 @@ LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:44:48
+  --> $DIR/feature-gate.rs:36:48
    |
 LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                                ^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:44:61
+  --> $DIR/feature-gate.rs:36:61
    |
 LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                                             ^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:56:8
+  --> $DIR/feature-gate.rs:43:8
    |
 LL |     if let Range { start: _, end: _ } = (true..true) && false {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL |     if let Range { start: _, end: _ } = (true..true) && false {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:64:12
+  --> $DIR/feature-gate.rs:50:12
    |
 LL |     while (let 0 = 1) {}
    |            ^^^^^^^^^
@@ -143,7 +143,7 @@ LL |     while (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:68:14
+  --> $DIR/feature-gate.rs:53:14
    |
 LL |     while (((let 0 = 1))) {}
    |              ^^^^^^^^^
@@ -152,7 +152,7 @@ LL |     while (((let 0 = 1))) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:72:19
+  --> $DIR/feature-gate.rs:56:19
    |
 LL |     while true && let 0 = 1 {}
    |                   ^^^^^^^^^
@@ -161,7 +161,7 @@ LL |     while true && let 0 = 1 {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:76:11
+  --> $DIR/feature-gate.rs:59:11
    |
 LL |     while let 0 = 1 && true {}
    |           ^^^^^^^^^
@@ -170,7 +170,7 @@ LL |     while let 0 = 1 && true {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:80:12
+  --> $DIR/feature-gate.rs:62:12
    |
 LL |     while (let 0 = 1) && true {}
    |            ^^^^^^^^^
@@ -179,7 +179,7 @@ LL |     while (let 0 = 1) && true {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:84:20
+  --> $DIR/feature-gate.rs:65:20
    |
 LL |     while true && (let 0 = 1) {}
    |                    ^^^^^^^^^
@@ -188,7 +188,7 @@ LL |     while true && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:88:12
+  --> $DIR/feature-gate.rs:68:12
    |
 LL |     while (let 0 = 1) && (let 0 = 1) {}
    |            ^^^^^^^^^
@@ -197,7 +197,7 @@ LL |     while (let 0 = 1) && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:88:27
+  --> $DIR/feature-gate.rs:68:27
    |
 LL |     while (let 0 = 1) && (let 0 = 1) {}
    |                           ^^^^^^^^^
@@ -206,7 +206,7 @@ LL |     while (let 0 = 1) && (let 0 = 1) {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:94:11
+  --> $DIR/feature-gate.rs:72:11
    |
 LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |           ^^^^^^^^^
@@ -215,7 +215,7 @@ LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:94:24
+  --> $DIR/feature-gate.rs:72:24
    |
 LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                        ^^^^^^^^^
@@ -224,7 +224,7 @@ LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:94:38
+  --> $DIR/feature-gate.rs:72:38
    |
 LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                      ^^^^^^^^^
@@ -233,7 +233,7 @@ LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:94:51
+  --> $DIR/feature-gate.rs:72:51
    |
 LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                                   ^^^^^^^^^
@@ -242,7 +242,7 @@ LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:94:64
+  --> $DIR/feature-gate.rs:72:64
    |
 LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
    |                                                                ^^^^^^^^^
@@ -251,7 +251,7 @@ LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:106:11
+  --> $DIR/feature-gate.rs:79:11
    |
 LL |     while let Range { start: _, end: _ } = (true..true) && false {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -260,7 +260,7 @@ LL |     while let Range { start: _, end: _ } = (true..true) && false {}
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:131:20
+  --> $DIR/feature-gate.rs:101:20
    |
 LL |     #[cfg(FALSE)] (let 0 = 1);
    |                    ^^^^^^^^^
@@ -269,7 +269,7 @@ LL |     #[cfg(FALSE)] (let 0 = 1);
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:114:17
+  --> $DIR/feature-gate.rs:88:17
    |
 LL |     noop_expr!((let 0 = 1));
    |                 ^^^^^^^^^
@@ -278,7 +278,7 @@ LL |     noop_expr!((let 0 = 1));
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:123:16
+  --> $DIR/feature-gate.rs:97:16
    |
 LL |     use_expr!((let 0 = 1 && 0 == 0));
    |                ^^^^^^^^^
@@ -287,7 +287,7 @@ LL |     use_expr!((let 0 = 1 && 0 == 0));
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
 error[E0658]: `let` expressions in this position are experimental
-  --> $DIR/feature-gate.rs:127:16
+  --> $DIR/feature-gate.rs:99:16
    |
 LL |     use_expr!((let 0 = 1));
    |                ^^^^^^^^^
@@ -295,294 +295,6 @@ LL |     use_expr!((let 0 = 1));
    = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
    = help: add `#![feature(let_chains)]` to the crate attributes to enable
 
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:14:9
-   |
-LL |     if (let 0 = 1) {}
-   |         ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:18:11
-   |
-LL |     if (((let 0 = 1))) {}
-   |           ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:22:16
-   |
-LL |     if true && let 0 = 1 {}
-   |                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:26:8
-   |
-LL |     if let 0 = 1 && true {}
-   |        ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:30:9
-   |
-LL |     if (let 0 = 1) && true {}
-   |         ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:34:17
-   |
-LL |     if true && (let 0 = 1) {}
-   |                 ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:38:9
-   |
-LL |     if (let 0 = 1) && (let 0 = 1) {}
-   |         ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:38:24
-   |
-LL |     if (let 0 = 1) && (let 0 = 1) {}
-   |                        ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:44:8
-   |
-LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |        ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:44:21
-   |
-LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                     ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:44:35
-   |
-LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                   ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:44:48
-   |
-LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:44:61
-   |
-LL |     if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                                             ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:56:8
-   |
-LL |     if let Range { start: _, end: _ } = (true..true) && false {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:64:12
-   |
-LL |     while (let 0 = 1) {}
-   |            ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:68:14
-   |
-LL |     while (((let 0 = 1))) {}
-   |              ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:72:19
-   |
-LL |     while true && let 0 = 1 {}
-   |                   ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:76:11
-   |
-LL |     while let 0 = 1 && true {}
-   |           ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:80:12
-   |
-LL |     while (let 0 = 1) && true {}
-   |            ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:84:20
-   |
-LL |     while true && (let 0 = 1) {}
-   |                    ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:88:12
-   |
-LL |     while (let 0 = 1) && (let 0 = 1) {}
-   |            ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:88:27
-   |
-LL |     while (let 0 = 1) && (let 0 = 1) {}
-   |                           ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:94:11
-   |
-LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |           ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:94:24
-   |
-LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                        ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:94:38
-   |
-LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                      ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:94:51
-   |
-LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                                   ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:94:64
-   |
-LL |     while let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) {}
-   |                                                                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:106:11
-   |
-LL |     while let Range { start: _, end: _ } = (true..true) && false {}
-   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:123:16
-   |
-LL |     use_expr!((let 0 = 1 && 0 == 0));
-   |                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:123:16
-   |
-LL |     use_expr!((let 0 = 1 && 0 == 0));
-   |                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:127:16
-   |
-LL |     use_expr!((let 0 = 1));
-   |                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: `let` expressions are not supported here
-  --> $DIR/feature-gate.rs:127:16
-   |
-LL |     use_expr!((let 0 = 1));
-   |                ^^^^^^^^^
-   |
-   = note: only supported directly in conditions of `if`- and `while`-expressions
-   = note: as well as when nested within `&&` and parenthesis in those conditions
-
-error: aborting due to 65 previous errors
+error: aborting due to 33 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/rfc-2497-if-let-chains/protect-precedences.stderr b/src/test/ui/rfc-2497-if-let-chains/protect-precedences.stderr
index 81cefdd29b3ea..a5ecf28c42ed6 100644
--- a/src/test/ui/rfc-2497-if-let-chains/protect-precedences.stderr
+++ b/src/test/ui/rfc-2497-if-let-chains/protect-precedences.stderr
@@ -1,10 +1,11 @@
-warning: unreachable block in `if` expression
-  --> $DIR/protect-precedences.rs:13:41
+warning: unreachable expression
+  --> $DIR/protect-precedences.rs:13:12
    |
 LL |         if let _ = return true && false {};
-   |                    -------------------- ^^ unreachable block in `if` expression
-   |                    |
-   |                    any code following this expression is unreachable
+   |            ^^^^^^^^--------------------
+   |            |       |
+   |            |       any code following this expression is unreachable
+   |            unreachable expression
    |
    = note: `#[warn(unreachable_code)]` on by default
 
diff --git a/src/test/ui/while-let.rs b/src/test/ui/while-let.rs
index cfbf7565cb6c8..5574324b25c13 100644
--- a/src/test/ui/while-let.rs
+++ b/src/test/ui/while-let.rs
@@ -5,26 +5,25 @@ fn macros() {
     macro_rules! foo{
         ($p:pat, $e:expr, $b:block) => {{
             while let $p = $e $b
-            //~^ WARN irrefutable while-let
-            //~| WARN irrefutable while-let
         }}
     }
-    macro_rules! bar{
-        ($p:pat, $e:expr, $b:block) => {{
-            foo!($p, $e, $b)
-        }}
+    macro_rules! bar {
+        ($p:pat, $e:expr, $b:block) => {{ foo!($p, $e, $b) }};
     }
 
     foo!(_a, 1, {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     });
     bar!(_a, 1, {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
     });
 }
 
 pub fn main() {
-    while let _a = 1 { //~ WARN irrefutable while-let
+    while let _a = 1 {
+        //~^ WARN irrefutable `let`
         println!("irrefutable pattern");
         break;
     }
diff --git a/src/test/ui/while-let.stderr b/src/test/ui/while-let.stderr
index 867c95c0e023d..47cd07c75c4c4 100644
--- a/src/test/ui/while-let.stderr
+++ b/src/test/ui/while-let.stderr
@@ -1,19 +1,14 @@
-warning: irrefutable while-let pattern
-  --> $DIR/while-let.rs:7:13
+warning: irrefutable `let` pattern
+  --> $DIR/while-let.rs:14:10
    |
-LL |               while let $p = $e $b
-   |               ^^^^^^^^^^^^^^^^^^^^
-...
-LL | /     foo!(_a, 1, {
-LL | |         println!("irrefutable pattern");
-LL | |     });
-   | |_______- in this macro invocation
+LL |     foo!(_a, 1, {
+   |          ^^
    |
    = note: `#[warn(irrefutable_let_patterns)]` on by default
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-warning: irrefutable while-let pattern
-  --> $DIR/while-let.rs:7:13
+warning: irrefutable `let` pattern
+  --> $DIR/while-let.rs:18:10
    |
 LL |               while let $p = $e $b
    |               ^^^^^^^^^^^^^^^^^^^^
@@ -25,14 +20,11 @@ LL | |     });
    |
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-warning: irrefutable while-let pattern
-  --> $DIR/while-let.rs:27:5
+warning: irrefutable `let` pattern
+  --> $DIR/while-let.rs:25:15
    |
-LL | /     while let _a = 1 {
-LL | |         println!("irrefutable pattern");
-LL | |         break;
-LL | |     }
-   | |_____^
+LL |     while let _a = 1 {
+   |               ^^
 
 warning: 3 warnings emitted