Point at whole let guard on irrefutable let pattern

Author: estebank

compiler/rustc_ast_lowering/src/expr.rs

@@ -532,7 +532,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let pat = self.lower_pat(&arm.pat);
         let guard = arm.guard.as_ref().map(|cond| {
             if let ExprKind::Let(ref pat, ref scrutinee) = cond.kind {
-                hir::Guard::IfLet(self.lower_pat(pat), self.lower_expr(scrutinee))
+                hir::Guard::IfLet(self.lower_pat(pat), self.lower_expr(scrutinee), cond.span)
             } else {
                 hir::Guard::If(self.lower_expr(cond))
             }

compiler/rustc_hir/src/hir.rs

@@ -1210,7 +1210,7 @@ pub struct Arm<'hir> {
 #[derive(Debug, HashStable_Generic)]
 pub enum Guard<'hir> {
     If(&'hir Expr<'hir>),
-    IfLet(&'hir Pat<'hir>, &'hir Expr<'hir>),
+    IfLet(&'hir Pat<'hir>, &'hir Expr<'hir>, Span),
 }
 
 #[derive(Debug, HashStable_Generic)]
@@ -1881,7 +1881,7 @@ pub enum MatchSource {
     /// An `if let _ = _ { .. }` (optionally with `else { .. }`).
     IfLetDesugar { contains_else_clause: bool, let_span: Span },
     /// An `if let _ = _ => { .. }` match guard.
-    IfLetGuardDesugar,
+    IfLetGuardDesugar { let_span: Span },
     /// A `while _ { .. }` (which was desugared to a `loop { match _ { .. } }`).
     WhileDesugar,
     /// A `while let _ = _ { .. }` (which was desugared to a
@@ -1900,7 +1900,7 @@ impl MatchSource {
         use MatchSource::*;
         match self {
             Normal => "match",
-            IfLetDesugar { .. } | IfLetGuardDesugar => "if",
+            IfLetDesugar { .. } | IfLetGuardDesugar { .. } => "if",
             WhileDesugar | WhileLetDesugar { .. } => "while",
             ForLoopDesugar => "for",
             TryDesugar => "?",

compiler/rustc_hir/src/intravisit.rs

@@ -1239,7 +1239,7 @@ pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm<'v>) {
     if let Some(ref g) = arm.guard {
         match g {
             Guard::If(ref e) => visitor.visit_expr(e),
-            Guard::IfLet(ref pat, ref e) => {
+            Guard::IfLet(ref pat, ref e, _) => {
                 visitor.visit_pat(pat);
                 visitor.visit_expr(e);
             }

compiler/rustc_hir_pretty/src/lib.rs

@@ -2043,7 +2043,7 @@ impl<'a> State<'a> {
                     self.print_expr(&e);
                     self.s.space();
                 }
-                hir::Guard::IfLet(pat, e) => {
+                hir::Guard::IfLet(pat, e, _) => {
                     self.word_nbsp("if");
                     self.word_nbsp("let");
                     self.print_pat(&pat);

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -781,7 +781,9 @@ fn convert_arm<'tcx>(cx: &mut Cx<'_, 'tcx>, arm: &'tcx hir::Arm<'tcx>) -> Arm<'t
         pattern: cx.pattern_from_hir(&arm.pat),
         guard: arm.guard.as_ref().map(|g| match g {
             hir::Guard::If(ref e) => Guard::If(e.to_ref()),
-            hir::Guard::IfLet(ref pat, ref e) => Guard::IfLet(cx.pattern_from_hir(pat), e.to_ref()),
+            hir::Guard::IfLet(ref pat, ref e, _) => {
+                Guard::IfLet(cx.pattern_from_hir(pat), e.to_ref())
+            }
         }),
         body: arm.body.to_ref(),
         lint_level: LintLevel::Explicit(arm.hir_id),

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -164,17 +164,17 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
         for arm in arms {
             // Check the arm for some things unrelated to exhaustiveness.
             self.check_patterns(&arm.pat);
-            if let Some(hir::Guard::IfLet(ref pat, _)) = arm.guard {
+            if let Some(hir::Guard::IfLet(ref pat, _, _)) = arm.guard {
                 self.check_patterns(pat);
             }
         }
 
         let mut cx = self.new_cx(scrut.hir_id);
 
         for arm in arms {
-            if let Some(hir::Guard::IfLet(ref pat, _)) = arm.guard {
+            if let Some(hir::Guard::IfLet(ref pat, _, span)) = arm.guard {
                 let tpat = self.lower_pattern(&mut cx, pat, &mut false).0;
-                check_if_let_guard(&mut cx, &tpat, pat.hir_id);
+                check_if_let_guard(&mut cx, &tpat, pat.hir_id, span);
             }
         }
 
@@ -379,7 +379,7 @@ fn irrefutable_let_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, source: hir::
             diag.help("consider instead using a `loop { ... }` with a `let` inside it");
             diag.emit()
         }
-        hir::MatchSource::IfLetGuardDesugar => {
+        hir::MatchSource::IfLetGuardDesugar { .. }=> {
             let mut diag = lint.build("irrefutable `if let` guard pattern");
             diag.note("this pattern will always match, so the guard is useless");
             diag.help("consider removing the guard and adding a `let` inside the match arm");
@@ -398,14 +398,20 @@ fn check_if_let_guard<'p, 'tcx>(
     cx: &mut MatchCheckCtxt<'p, 'tcx>,
     pat: &'p super::Pat<'tcx>,
     pat_id: HirId,
+    let_span: Span,
 ) {
     let arms = [MatchArm { pat, hir_id: pat_id, has_guard: false }];
     let report = compute_match_usefulness(&cx, &arms, pat_id, pat.ty);
-    report_arm_reachability(&cx, &report, hir::MatchSource::IfLetGuardDesugar);
+    report_arm_reachability(&cx, &report, hir::MatchSource::IfLetGuardDesugar { let_span });
 
     if report.non_exhaustiveness_witnesses.is_empty() {
-        // The match is exhaustive, i.e. the `if let` pattern is irrefutable.
-        irrefutable_let_pattern(cx.tcx, pat.span, pat_id, hir::MatchSource::IfLetGuardDesugar)
+        // The match is exhaustive, i.e. the if let pattern is irrefutable.
+        irrefutable_let_pattern(
+            cx.tcx,
+            let_span,
+            pat_id,
+            hir::MatchSource::IfLetGuardDesugar { let_span },
+        )
     }
 }
 
@@ -435,9 +441,9 @@ fn report_arm_reachability<'p, 'tcx>(
                         }
                     }
 
-                    hir::MatchSource::IfLetGuardDesugar => {
+                    hir::MatchSource::IfLetGuardDesugar { let_span } => {
                         assert_eq!(arm_index, 0);
-                        unreachable_pattern(cx.tcx, arm.pat.span, arm.hir_id, None);
+                        unreachable_pattern(cx.tcx, let_span, arm.hir_id, None);
                     }
 
                     hir::MatchSource::ForLoopDesugar | hir::MatchSource::Normal => {

compiler/rustc_passes/src/check_const.rs

@@ -45,7 +45,9 @@ impl NonConstExpr {
                 return None;
             }
 
-            Self::Match(IfLetGuardDesugar) => bug!("`if let` guard outside a `match` expression"),
+            Self::Match(IfLetGuardDesugar { .. }) => {
+                bug!("if-let guard outside a `match` expression")
+            }
 
             // All other expressions are allowed.
             Self::Loop(Loop | While | WhileLet)

compiler/rustc_passes/src/liveness.rs

@@ -360,7 +360,7 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
 
     fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
         self.add_from_pat(&arm.pat);
-        if let Some(hir::Guard::IfLet(ref pat, _)) = arm.guard {
+        if let Some(hir::Guard::IfLet(ref pat, _, _)) = arm.guard {
             self.add_from_pat(pat);
         }
         intravisit::walk_arm(self, arm);
@@ -891,7 +891,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
                     let guard_succ = arm.guard.as_ref().map_or(body_succ, |g| match g {
                         hir::Guard::If(e) => self.propagate_through_expr(e, body_succ),
-                        hir::Guard::IfLet(pat, e) => {
+                        hir::Guard::IfLet(pat, e, _) => {
                             let let_bind = self.define_bindings_in_pat(pat, body_succ);
                             self.propagate_through_expr(e, let_bind)
                         }

compiler/rustc_typeck/src/check/_match.rs

@@ -134,7 +134,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     hir::Guard::If(e) => {
                         self.check_expr_has_type_or_error(e, tcx.types.bool, |_| {});
                     }
-                    hir::Guard::IfLet(pat, e) => {
+                    hir::Guard::IfLet(pat, e, _) => {
                         let scrutinee_ty = self.demand_scrutinee_type(
                             e,
                             pat.contains_explicit_ref_binding(),

compiler/rustc_typeck/src/check/generator_interior.rs

@@ -248,7 +248,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> {
                 Guard::If(ref e) => {
                     self.visit_expr(e);
                 }
-                Guard::IfLet(ref pat, ref e) => {
+                Guard::IfLet(ref pat, ref e, _) => {
                     self.visit_pat(pat);
                     self.visit_expr(e);
                 }