diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index bf7589e84adc4..fff9350899d0b 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1,4 +1,6 @@
-use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
+use super::{
+    ConditionScope, ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs,
+};
 
 use rustc_ast::attr;
 use rustc_ast::ptr::P as AstP;
@@ -15,6 +17,8 @@ use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::{hygiene::ForLoopLoc, DUMMY_SP};
 
+use std::mem;
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] {
         self.arena.alloc_from_iter(exprs.iter().map(|x| self.lower_expr_mut(x)))
@@ -87,7 +91,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::AddrOf(k, m, ohs)
                 }
                 ExprKind::Let(ref pat, ref scrutinee, span) => {
-                    hir::ExprKind::Let(self.lower_pat(pat), self.lower_expr(scrutinee), span)
+                    let source = match self.condition_scope {
+                        Some(ConditionScope::Guard) => hir::LetSource::Guard,
+                        Some(ConditionScope::If) => hir::LetSource::If,
+                        Some(ConditionScope::While) => hir::LetSource::While,
+                        None => hir::LetSource::Local,
+                    };
+                    hir::ExprKind::Let(
+                        self.lower_pat(pat),
+                        self.lower_expr(scrutinee),
+                        span,
+                        source,
+                    )
                 }
                 ExprKind::If(ref cond, ref then, ref else_opt) => {
                     self.lower_expr_if(cond, then, else_opt.as_deref())
@@ -354,14 +369,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         then: &Block,
         else_opt: Option<&Expr>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.lower_expr(cond);
+        let lowered_cond = self.with_condition_scope(ConditionScope::If, |t| t.lower_expr(cond));
         let new_cond = self.manage_let_cond(lowered_cond);
-        let then_expr = self.lower_block_expr(then);
-        if let Some(rslt) = else_opt {
-            hir::ExprKind::If(new_cond, self.arena.alloc(then_expr), Some(self.lower_expr(rslt)))
-        } else {
-            hir::ExprKind::If(new_cond, self.arena.alloc(then_expr), None)
-        }
+        let then_expr = self.arena.alloc(self.lower_block_expr(then));
+        let else_opt = else_opt.map(|e| self.lower_expr(e));
+        hir::ExprKind::If(new_cond, then_expr, else_opt)
     }
 
     // If `cond` kind is `let`, returns `let`. Otherwise, wraps and returns `cond`
@@ -400,7 +412,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.with_loop_condition_scope(|t| t.lower_expr(cond));
+        let lowered_cond = self.with_condition_scope(ConditionScope::While, |t| t.lower_expr(cond));
         let new_cond = self.manage_let_cond(lowered_cond);
         let then = self.lower_block_expr(body);
         let expr_break = self.expr_break(span, ThinVec::new());
@@ -473,7 +485,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             if let ExprKind::Let(ref pat, ref scrutinee, _) = cond.kind {
                 hir::Guard::IfLet(self.lower_pat(pat), self.lower_expr(scrutinee))
             } else {
-                hir::Guard::If(self.lower_expr(cond))
+                let cond = self.with_condition_scope(ConditionScope::Guard, |t| t.lower_expr(cond));
+                hir::Guard::If(cond)
             }
         });
         let hir_id = self.next_id();
@@ -732,7 +745,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             (body_id, generator_option)
         });
 
-        // Lower outside new scope to preserve `is_in_loop_condition`.
+        // Lower outside new scope to preserve `condition_scope`.
         let fn_decl = self.lower_fn_decl(decl, None, false, None);
 
         hir::ExprKind::Closure(capture_clause, fn_decl, body_id, fn_decl_span, generator_option)
@@ -1132,7 +1145,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_jump_destination(&mut self, id: NodeId, opt_label: Option<Label>) -> hir::Destination {
-        if self.is_in_loop_condition && opt_label.is_none() {
+        if opt_label.is_none() && self.condition_scope == Some(ConditionScope::While) {
             hir::Destination {
                 label: None,
                 target_id: Err(hir::LoopIdError::UnlabeledCfInWhileCondition),
@@ -1160,8 +1173,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn with_loop_scope<T>(&mut self, loop_id: NodeId, f: impl FnOnce(&mut Self) -> T) -> T {
         // We're no longer in the base loop's condition; we're in another loop.
-        let was_in_loop_condition = self.is_in_loop_condition;
-        self.is_in_loop_condition = false;
+        let condition_scope = mem::take(&mut self.condition_scope);
 
         let len = self.loop_scopes.len();
         self.loop_scopes.push(loop_id);
@@ -1175,19 +1187,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         self.loop_scopes.pop().unwrap();
 
-        self.is_in_loop_condition = was_in_loop_condition;
+        self.condition_scope = condition_scope;
 
         result
     }
 
-    fn with_loop_condition_scope<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
-        let was_in_loop_condition = self.is_in_loop_condition;
-        self.is_in_loop_condition = true;
-
+    fn with_condition_scope<T>(
+        &mut self,
+        condition_scope: ConditionScope,
+        f: impl FnOnce(&mut Self) -> T,
+    ) -> T {
+        let condition_scope = mem::replace(&mut self.condition_scope, Some(condition_scope));
         let result = f(self);
-
-        self.is_in_loop_condition = was_in_loop_condition;
-
+        self.condition_scope = condition_scope;
         result
     }
 
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index d41b3b8146624..1283c4df0d4a9 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -122,8 +122,8 @@ struct LoweringContext<'a, 'hir: 'a> {
     current_item: Option<Span>,
 
     catch_scopes: Vec<NodeId>,
+    condition_scope: Option<ConditionScope>,
     loop_scopes: Vec<NodeId>,
-    is_in_loop_condition: bool,
     is_in_trait_impl: bool,
     is_in_dyn_type: bool,
 
@@ -332,8 +332,8 @@ pub fn lower_crate<'a, 'hir>(
         attrs: BTreeMap::default(),
         non_exported_macro_attrs: Vec::new(),
         catch_scopes: Vec::new(),
+        condition_scope: None,
         loop_scopes: Vec::new(),
-        is_in_loop_condition: false,
         is_in_trait_impl: false,
         is_in_dyn_type: false,
         anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough,
@@ -419,6 +419,13 @@ enum AnonymousLifetimeMode {
     PassThrough,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+enum ConditionScope {
+    Guard,
+    If,
+    While,
+}
+
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_crate(mut self, c: &Crate) -> &'hir hir::Crate<'hir> {
         /// Full-crate AST visitor that inserts into a fresh
@@ -957,17 +964,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn with_new_scopes<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
-        let was_in_loop_condition = self.is_in_loop_condition;
-        self.is_in_loop_condition = false;
-
         let catch_scopes = mem::take(&mut self.catch_scopes);
+        let condition_scope = mem::take(&mut self.condition_scope);
         let loop_scopes = mem::take(&mut self.loop_scopes);
         let ret = f(self);
         self.catch_scopes = catch_scopes;
+        self.condition_scope = condition_scope;
         self.loop_scopes = loop_scopes;
-
-        self.is_in_loop_condition = was_in_loop_condition;
-
         ret
     }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 4e233ed14577d..6ae44fc6dcbc9 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1732,7 +1732,7 @@ pub enum ExprKind<'hir> {
     ///
     /// These are not `Local` and only occur as expressions.
     /// The `let Some(x) = foo()` in `if let Some(x) = foo()` is an example of `Let(..)`.
-    Let(&'hir Pat<'hir>, &'hir Expr<'hir>, Span),
+    Let(&'hir Pat<'hir>, &'hir Expr<'hir>, Span, LetSource),
     /// An `if` block, with an optional else block.
     ///
     /// I.e., `if <expr> { <expr> } else { <expr> }`.
@@ -1886,6 +1886,15 @@ pub enum LocalSource {
     AssignDesugar(Span),
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)]
+#[derive(HashStable_Generic)]
+pub enum LetSource {
+    Guard,
+    If,
+    Local,
+    While,
+}
+
 /// Hints at the original code for a `match _ { .. }`.
 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)]
 #[derive(HashStable_Generic)]
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 1cbe3b12c8203..389883d215ff7 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1163,7 +1163,7 @@ 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, _) => {
+        ExprKind::Let(ref pat, ref expr, ..) => {
             visitor.visit_expr(expr);
             visitor.visit_pat(pat);
         }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 9c286ad5ccfe9..07bd857063ad3 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1526,7 +1526,7 @@ impl<'a> State<'a> {
                 // Print `}`:
                 self.bclose_maybe_open(expr.span, true);
             }
-            hir::ExprKind::Let(ref pat, ref scrutinee, _) => {
+            hir::ExprKind::Let(ref pat, ref scrutinee, ..) => {
                 self.print_let(pat, scrutinee);
             }
             hir::ExprKind::If(ref test, ref blk, ref elseopt) => {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 6bbf1faf4837f..c3b045ed66fb9 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -590,7 +590,7 @@ impl<'tcx> Cx<'tcx> {
                 },
                 Err(err) => bug!("invalid loop id for continue: {}", err),
             },
-            hir::ExprKind::Let(ref pat, ref expr, _) => {
+            hir::ExprKind::Let(ref pat, ref expr, ..) => {
                 ExprKind::Let { expr: self.mirror_expr(expr), pat: self.pattern_from_hir(pat) }
             }
             hir::ExprKind::If(cond, then, else_opt) => ExprKind::If {
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 50cbe0f71f552..a6b921f49c049 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,11 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
 
     fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
         intravisit::walk_expr(self, ex);
-        match &ex.kind {
-            hir::ExprKind::Match(scrut, arms, source) => self.check_match(scrut, arms, *source),
-            hir::ExprKind::Let(pat, scrut, span) => self.check_let(pat, scrut, *span),
+        match ex.kind {
+            hir::ExprKind::Match(scrut, arms, source) => self.check_match(scrut, arms, source),
+            hir::ExprKind::Let(pat, scrut, span, source) => {
+                self.check_let(pat, scrut, span, source)
+            }
             _ => {}
         }
     }
@@ -118,31 +120,6 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
         check_for_bindings_named_same_as_variants(self, pat);
     }
 
-    fn let_source(&mut self, pat: &'tcx hir::Pat<'tcx>, _expr: &hir::Expr<'_>) -> LetSource {
-        let hir = self.tcx.hir();
-        let parent = hir.get_parent_node(pat.hir_id);
-        let parent_parent = hir.get_parent_node(parent);
-        let parent_parent_node = hir.get(parent_parent);
-
-        let parent_parent_parent = hir.get_parent_node(parent_parent);
-        let parent_parent_parent_parent = hir.get_parent_node(parent_parent_parent);
-        let parent_parent_parent_parent_node = hir.get(parent_parent_parent_parent);
-
-        if let hir::Node::Expr(hir::Expr {
-            kind: hir::ExprKind::Loop(_, _, hir::LoopSource::While, _),
-            ..
-        }) = parent_parent_parent_parent_node
-        {
-            LetSource::WhileLet
-        } else if let hir::Node::Expr(hir::Expr { kind: hir::ExprKind::If { .. }, .. }) =
-            parent_parent_node
-        {
-            LetSource::IfLet
-        } else {
-            LetSource::GenericLet
-        }
-    }
-
     fn lower_pattern<'p>(
         &self,
         cx: &mut MatchCheckCtxt<'p, 'tcx>,
@@ -170,12 +147,17 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
         }
     }
 
-    fn check_let(&mut self, pat: &'tcx hir::Pat<'tcx>, expr: &hir::Expr<'_>, span: Span) {
+    fn check_let(
+        &mut self,
+        pat: &'tcx hir::Pat<'tcx>,
+        expr: &hir::Expr<'_>,
+        span: Span,
+        source: hir::LetSource,
+    ) {
         self.check_patterns(pat);
-        let ls = self.let_source(pat, expr);
         let mut cx = self.new_cx(expr.hir_id);
         let tpat = self.lower_pattern(&mut cx, pat, &mut false).0;
-        check_let_reachability(&mut cx, ls, pat.hir_id, &tpat, span);
+        check_let_reachability(&mut cx, source, pat.hir_id, &tpat, span);
     }
 
     fn check_match(
@@ -194,7 +176,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
                 let tpat = self.lower_pattern(&mut cx, pat, &mut false).0;
                 check_let_reachability(
                     &mut cx,
-                    LetSource::IfLetGuard,
+                    hir::LetSource::Guard,
                     pat.hir_id,
                     &tpat,
                     tpat.span,
@@ -397,7 +379,7 @@ fn unreachable_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, catchall: Option<
     });
 }
 
-fn irrefutable_let_pattern(id: HirId, ls: LetSource, span: Span, tcx: TyCtxt<'_>) {
+fn irrefutable_let_pattern(id: HirId, ls: hir::LetSource, span: Span, tcx: TyCtxt<'_>) {
     macro_rules! emit_diag {
         (
             $lint:expr,
@@ -413,18 +395,24 @@ fn irrefutable_let_pattern(id: HirId, ls: LetSource, span: Span, tcx: TyCtxt<'_>
     }
 
     tcx.struct_span_lint_hir(IRREFUTABLE_LET_PATTERNS, id, span, |lint| match ls {
-        LetSource::GenericLet => {
-            emit_diag!(lint, "`let`", "`let` is useless", "removing `let`");
-        }
-        LetSource::IfLet => {
-            emit_diag!(
-                lint,
-                "`if let`",
-                "`if let` is useless",
-                "replacing the `if let` with a `let`"
-            );
+        hir::LetSource::If => {
+            if matches!(
+                tcx.hir().parent_iter(id).nth(1).unwrap().1,
+                hir::Node::Expr(hir::Expr { kind: hir::ExprKind::If { .. }, .. })
+            ) {
+                // basic `if let`
+                emit_diag!(
+                    lint,
+                    "`if let`",
+                    "`if let` is useless",
+                    "replacing the `if let` with a `let`"
+                );
+            } else {
+                // `let` inside if-let-chains
+                emit_diag!(lint, "`let`", "`let` is useless", "removing `let`");
+            }
         }
-        LetSource::IfLetGuard => {
+        hir::LetSource::Guard => {
             emit_diag!(
                 lint,
                 "`if let` guard",
@@ -432,7 +420,7 @@ fn irrefutable_let_pattern(id: HirId, ls: LetSource, span: Span, tcx: TyCtxt<'_>
                 "removing the guard and adding a `let` inside the match arm"
             );
         }
-        LetSource::WhileLet => {
+        hir::LetSource::While => {
             emit_diag!(
                 lint,
                 "`while let`",
@@ -440,12 +428,13 @@ fn irrefutable_let_pattern(id: HirId, ls: LetSource, span: Span, tcx: TyCtxt<'_>
                 "instead using a `loop { ... }` with a `let` inside it"
             );
         }
+        hir::LetSource::Local => {}
     });
 }
 
 fn check_let_reachability<'p, 'tcx>(
     cx: &mut MatchCheckCtxt<'p, 'tcx>,
-    ls: LetSource,
+    ls: hir::LetSource,
     pat_id: HirId,
     pat: &'p super::Pat<'tcx>,
     span: Span,
@@ -455,7 +444,7 @@ fn check_let_reachability<'p, 'tcx>(
 
     report_arm_reachability(&cx, &report, |arm_index, arm_span, arm_hir_id, _| {
         match ls {
-            LetSource::IfLet | LetSource::WhileLet => {
+            hir::LetSource::If | hir::LetSource::While => {
                 match arm_index {
                     // The arm with the user-specified pattern.
                     0 => unreachable_pattern(cx.tcx, arm_span, arm_hir_id, None),
@@ -464,7 +453,7 @@ fn check_let_reachability<'p, 'tcx>(
                     _ => bug!(),
                 }
             }
-            LetSource::IfLetGuard if arm_index == 0 => {
+            hir::LetSource::Guard if arm_index == 0 => {
                 unreachable_pattern(cx.tcx, arm_span, arm_hir_id, None);
             }
             _ => {}
@@ -781,11 +770,3 @@ fn check_borrow_conflicts_in_at_patterns(cx: &MatchVisitor<'_, '_>, pat: &Pat<'_
         err.emit();
     }
 }
-
-#[derive(Clone, Copy, Debug)]
-pub enum LetSource {
-    GenericLet,
-    IfLet,
-    IfLetGuard,
-    WhileLet,
-}
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 2cd780e1b9bbe..b33b1ccd16254 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -857,7 +857,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 })
             }
 
-            hir::ExprKind::Let(ref pat, ref scrutinee, _) => {
+            hir::ExprKind::Let(ref pat, ref scrutinee, ..) => {
                 let succ = self.propagate_through_expr(scrutinee, succ);
                 self.define_bindings_in_pat(pat, succ)
             }
diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
index 23ce4275d4009..37d4df3ea0e11 100644
--- a/compiler/rustc_typeck/src/check/expr.rs
+++ b/compiler/rustc_typeck/src/check/expr.rs
@@ -266,7 +266,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             ExprKind::Ret(ref expr_opt) => self.check_expr_return(expr_opt.as_deref(), expr),
-            ExprKind::Let(pat, let_expr, _) => self.check_expr_let(let_expr, pat),
+            ExprKind::Let(pat, let_expr, ..) => self.check_expr_let(let_expr, pat),
             ExprKind::Loop(body, _, source, _) => {
                 self.check_expr_loop(body, source, expected, expr)
             }
diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs
index b0c95939bb77d..364000928c108 100644
--- a/compiler/rustc_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_typeck/src/expr_use_visitor.rs
@@ -229,7 +229,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                 }
             }
 
-            hir::ExprKind::Let(ref pat, ref expr, _) => {
+            hir::ExprKind::Let(ref pat, ref expr, ..) => {
                 self.walk_local(expr, pat, |t| t.borrow_expr(&expr, ty::ImmBorrow));
             }
 
diff --git a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
index 2c46971d5f741..1c56e4a39b28c 100644
--- a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs
@@ -111,7 +111,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Unary(_, e)
         | ExprKind::Cast(e, _)
         | ExprKind::Type(e, _)
-        | ExprKind::Let(_, e, _)
+        | ExprKind::Let(_, e, ..)
         | ExprKind::Field(e, _)
         | ExprKind::AddrOf(_, _, e)
         | ExprKind::Struct(_, _, Some(e))
diff --git a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
index 35cff4141a903..217e87e317dd2 100644
--- a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
+++ b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
@@ -117,7 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
                 }
             }
         }
-        if let ExprKind::Let(let_pat, let_expr, _) = expr.kind {
+        if let ExprKind::Let(let_pat, let_expr, ..) = expr.kind {
             if let Some(ref expr_ty) = cx.typeck_results().node_type_opt(let_expr.hir_id) {
                 if in_external_macro(cx.sess(), let_pat.span) {
                     return;
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index f93d7782e2511..00670aec8d18f 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -208,7 +208,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
         print!("    if let ExprKind::");
         let current = format!("{}.kind", self.current);
         match expr.kind {
-            ExprKind::Let(pat, expr, _) => {
+            ExprKind::Let(pat, expr, ..) => {
                 let let_pat = self.next("pat");
                 let let_expr = self.next("expr");
                 println!("    Let(ref {}, ref {}, _) = {};", let_pat, let_expr, current);
diff --git a/src/tools/clippy/clippy_lints/src/utils/inspector.rs b/src/tools/clippy/clippy_lints/src/utils/inspector.rs
index 6bf216cec1670..35403aa42a0df 100644
--- a/src/tools/clippy/clippy_lints/src/utils/inspector.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/inspector.rs
@@ -142,7 +142,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, arg, indent + 1);
             }
         },
-        hir::ExprKind::Let(ref pat, ref expr, _) => {
+        hir::ExprKind::Let(ref pat, ref expr, ..) => {
             print_pat(cx, pat, indent + 1);
             print_expr(cx, expr, indent + 1);
         },
diff --git a/src/tools/clippy/clippy_utils/src/higher.rs b/src/tools/clippy/clippy_utils/src/higher.rs
index 29b698e56e3c0..977348b50efed 100644
--- a/src/tools/clippy/clippy_utils/src/higher.rs
+++ b/src/tools/clippy/clippy_utils/src/higher.rs
@@ -90,7 +90,7 @@ impl<'hir> IfLet<'hir> {
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::If(
             Expr {
-                kind: ExprKind::Let(let_pat, let_expr, _),
+                kind: ExprKind::Let(let_pat, let_expr, ..),
                 ..
             },
             if_then,
@@ -329,7 +329,7 @@ impl<'hir> WhileLet<'hir> {
                 kind:
                     ExprKind::If(
                         Expr {
-                            kind: ExprKind::Let(let_pat, let_expr, _),
+                            kind: ExprKind::Let(let_pat, let_expr, ..),
                             ..
                         },
                         if_then,
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index a44f2df2fd631..e66f12324c17e 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -232,8 +232,8 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&ExprKind::If(lc, lt, ref le), &ExprKind::If(rc, rt, ref re)) => {
                 self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
             },
-            (&ExprKind::Let(ref lp, ref le, _), &ExprKind::Let(ref rp, ref re, _)) => {
-                self.eq_pat(lp, rp) && self.eq_expr(le, re)
+            (&ExprKind::Let(ref lp, ref le, _, ls), &ExprKind::Let(ref rp, ref re, _, rs)) => {
+                self.eq_pat(lp, rp) && self.eq_expr(le, re) && ls == rs
             },
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
             (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
@@ -668,9 +668,10 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     }
                 }
             },
-            ExprKind::Let(ref pat, ref expr, _) => {
+            ExprKind::Let(ref pat, ref expr, _, source) => {
                 self.hash_expr(expr);
                 self.hash_pat(pat);
+                std::mem::discriminant(&source).hash(&mut self.s);
             },
             ExprKind::LlvmInlineAsm(..) | ExprKind::Err => {},
             ExprKind::Lit(ref l) => {