Produce a better error for irrefutable if let patterns

Modify ast::ExprMatch to include a new value of type ast::MatchSource,
making it easy to tell whether the match was written literally or
produced via desugaring. This allows us to customize error messages
appropriately.

Author: lilyball

src/librustc/diagnostics.rs

@@ -19,6 +19,11 @@ register_diagnostic!(E0001, r##"
     one is too specific or the ordering is incorrect.
 "##)
 
+register_diagnostic!(E0162, r##"
+    This error is produced by an `if let` expression where the pattern is irrefutable.
+    An `if let` that can never fail is considered an error.
+"##)
+
 register_diagnostics!(
     E0002,
     E0003,

src/librustc/lint/builtin.rs

@@ -1091,7 +1091,10 @@ impl LintPass for UnnecessaryParens {
         let (value, msg, struct_lit_needs_parens) = match e.node {
             ast::ExprIf(ref cond, _, _) => (cond, "`if` condition", true),
             ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
-            ast::ExprMatch(ref head, _) => (head, "`match` head expression", true),
+            ast::ExprMatch(ref head, _, source) => match source {
+                ast::MatchNormal => (head, "`match` head expression", true),
+                ast::MatchIfLetDesugar => (head, "`if let` head expression", true)
+            },
             ast::ExprRet(Some(ref value)) => (value, "`return` value", false),
             ast::ExprAssign(_, ref value) => (value, "assigned value", false),
             ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false),
@@ -1241,7 +1244,7 @@ impl LintPass for UnusedMut {
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
         match e.node {
-            ast::ExprMatch(_, ref arms) => {
+            ast::ExprMatch(_, ref arms, _) => {
                 for a in arms.iter() {
                     self.check_unused_mut_pat(cx, a.pats.as_slice())
                 }

src/librustc/middle/cfg/construct.rs

@@ -324,7 +324,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 expr_exit
             }
 
-            ast::ExprMatch(ref discr, ref arms) => {
+            ast::ExprMatch(ref discr, ref arms, _) => {
                 //
                 //     [pred]
                 //       |

src/librustc/middle/check_match.rs

@@ -147,7 +147,7 @@ pub fn check_crate(tcx: &ty::ctxt) {
 fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
     visit::walk_expr(cx, ex);
     match ex.node {
-        ExprMatch(ref scrut, ref arms) => {
+        ExprMatch(ref scrut, ref arms, source) => {
             // First, check legality of move bindings.
             for arm in arms.iter() {
                 check_legality_of_move_bindings(cx,
@@ -184,7 +184,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
             }
 
             // Fourth, check for unreachable arms.
-            check_arms(cx, inlined_arms.as_slice());
+            check_arms(cx, inlined_arms.as_slice(), source);
 
             // Finally, check if the whole match expression is exhaustive.
             // Check for empty enum, because is_useful only works on inhabited types.
@@ -252,13 +252,31 @@ fn check_for_static_nan(cx: &MatchCheckCtxt, pats: &[P<Pat>]) {
 }
 
 // Check for unreachable patterns
-fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)]) {
+fn check_arms(cx: &MatchCheckCtxt, arms: &[(Vec<P<Pat>>, Option<&Expr>)], source: MatchSource) {
     let mut seen = Matrix(vec![]);
+    let mut printed_if_let_err = false;
     for &(ref pats, guard) in arms.iter() {
         for pat in pats.iter() {
             let v = vec![&**pat];
+
             match is_useful(cx, &seen, v.as_slice(), LeaveOutWitness) {
-                NotUseful => span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern"),
+                NotUseful => {
+                    if source == MatchIfLetDesugar {
+                        if printed_if_let_err {
+                            // we already printed an irrefutable if-let pattern error.
+                            // We don't want two, that's just confusing.
+                        } else {
+                            // find the first arm pattern so we can use its span
+                            let &(ref first_arm_pats, _) = &arms[0]; // we know there's at least 1 arm
+                            let first_pat = first_arm_pats.get(0); // and it's safe to assume 1 pat
+                            let span = first_pat.span;
+                            span_err!(cx.tcx.sess, span, E0162, "irrefutable if-let pattern");
+                            printed_if_let_err = true;
+                        }
+                    } else {
+                        span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern");
+                    }
+                }
                 Useful => (),
                 UsefulWithWitness(_) => unreachable!()
             }

src/librustc/middle/expr_use_visitor.rs

@@ -376,7 +376,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
 
             ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
 
-            ast::ExprMatch(ref discr, ref arms) => {
+            ast::ExprMatch(ref discr, ref arms, _) => {
                 let discr_cmt = return_if_err!(self.mc.cat_expr(&**discr));
                 self.borrow_expr(&**discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant);
 

src/librustc/middle/liveness.rs

@@ -1029,7 +1029,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             self.propagate_through_loop(expr, LoopLoop, &**blk, succ)
           }
 
-          ExprMatch(ref e, ref arms) => {
+          ExprMatch(ref e, ref arms, _) => {
             //
             //      (e)
             //       |

src/librustc/middle/trans/debuginfo.rs

@@ -3659,7 +3659,7 @@ fn populate_scope_map(cx: &CrateContext,
                 }
             }
 
-            ast::ExprMatch(ref discriminant_exp, ref arms) => {
+            ast::ExprMatch(ref discriminant_exp, ref arms, _) => {
                 walk_expr(cx, &**discriminant_exp, scope_stack, scope_map);
 
                 // For each arm we have to first walk the pattern as these might

src/librustc/middle/trans/expr.rs

@@ -1013,7 +1013,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         ast::ExprIf(ref cond, ref thn, ref els) => {
             controlflow::trans_if(bcx, expr.id, &**cond, &**thn, els.as_ref().map(|e| &**e), dest)
         }
-        ast::ExprMatch(ref discr, ref arms) => {
+        ast::ExprMatch(ref discr, ref arms, _) => {
             _match::trans_match(bcx, expr, &**discr, arms.as_slice(), dest)
         }
         ast::ExprBlock(ref blk) => {

src/librustc/middle/typeck/check/mod.rs

@@ -4144,7 +4144,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
             fcx.write_nil(id);
         }
       }
-      ast::ExprMatch(ref discrim, ref arms) => {
+      ast::ExprMatch(ref discrim, ref arms, _) => {
         _match::check_match(fcx, expr, &**discrim, arms.as_slice());
       }
       ast::ExprFnBlock(_, ref decl, ref body) => {

src/librustc/middle/typeck/check/regionck.rs

@@ -725,7 +725,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
             visit::walk_expr(rcx, expr);
         }
 
-        ast::ExprMatch(ref discr, ref arms) => {
+        ast::ExprMatch(ref discr, ref arms, _) => {
             link_match(rcx, &**discr, arms.as_slice());
 
             visit::walk_expr(rcx, expr);