Update based on PR feedback

Author: lilyball

src/doc/rust.md

@@ -2457,7 +2457,7 @@ The currently implemented features of the reference compiler are:
             whether this will continue as a feature or not. For these reasons,
             the glob import statement has been hidden behind this feature flag.
 
-* `if_let` - Allows use of the `if let` desugaring syntax.
+* `if_let` - Allows use of the `if let` syntax.
 
 * `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
                  are inherently unstable and no promise about them is made.

src/librustc/front/feature_gate.rs

@@ -347,7 +347,7 @@ impl<'a> Visitor<()> for Context<'a> {
                 // should not have happened, but the ExprMatch check is included just
                 // in case.
                 self.gate_feature("if_let", e.span,
-                                  "`if let` desugaring is experimental");
+                                  "`if let` syntax is experimental");
             }
             _ => {}
         }

src/librustc/middle/cfg/construct.rs

@@ -225,7 +225,9 @@ impl<'a> CFGBuilder<'a> {
                 self.add_node(expr.id, [then_exit, else_exit])           // 4, 5
             }
 
-            ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+            ast::ExprIfLet(..) => {
+                self.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+            }
 
             ast::ExprWhile(ref cond, ref body) => {
                 //

src/librustc/middle/expr_use_visitor.rs

@@ -356,7 +356,9 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                 }
             }
 
-            ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+            ast::ExprIfLet(..) => {
+                self.tcx().sess.span_bug(expr.span, "non-desugared ExprIfLet");
+            }
 
             ast::ExprMatch(ref discr, ref arms, _) => {
                 // treatment of the discriminant is handled while

src/librustc/middle/liveness.rs

@@ -491,7 +491,9 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
         ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
         visit::walk_expr(ir, expr, ());
       }
-      ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+      ExprIfLet(..) => {
+          ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+      }
       ExprForLoop(ref pat, _, _, _) => {
         pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
             debug!("adding local variable {} from for loop with bm {:?}",
@@ -1018,7 +1020,9 @@ impl<'a> Liveness<'a> {
             self.propagate_through_expr(&**cond, ln)
           }
 
-          ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+          ExprIfLet(..) => {
+              self.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+          }
 
           ExprWhile(ref cond, ref blk) => {
             self.propagate_through_loop(expr,
@@ -1461,7 +1465,9 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
       ExprPath(..) | ExprBox(..) | ExprForLoop(..) => {
         visit::walk_expr(this, expr, ());
       }
-      ExprIfLet(..) => fail!("non-desugared ExprIfLet")
+      ExprIfLet(..) => {
+        this.ir.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+      }
     }
 }
 

src/librustc/middle/mem_categorization.rs

@@ -515,7 +515,9 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> {
             Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
           }
 
-          ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet")
+          ast::ExprIfLet(..) => {
+            self.tcx().sess.span_bug(expr.span, "non-desugared ExprIfLet");
+          }
         }
     }
 

src/librustc/middle/ty.rs

@@ -3429,7 +3429,9 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
             RvalueDpsExpr
         }
 
-        ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+        ast::ExprIfLet(..) => {
+            tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+        }
 
         ast::ExprLit(lit) if lit_is_str(lit) => {
             RvalueDpsExpr

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

@@ -3430,7 +3430,9 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         check_then_else(fcx, &**cond, &**then_blk, opt_else_expr.clone(),
                         id, expr.span, expected);
       }
-      ast::ExprIfLet(..) => fail!("non-desugared ExprIfLet"),
+      ast::ExprIfLet(..) => {
+          tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+      }
       ast::ExprWhile(ref cond, ref body) => {
         check_expr_has_type(fcx, &**cond, ty::mk_bool());
         check_block_no_value(fcx, &**body);

src/libsyntax/ext/expand.rs

@@ -127,26 +127,22 @@ fn expand_expr(e: Gc<ast::Expr>, fld: &mut MacroExpander) -> Gc<ast::Expr> {
         }
 
         // Desugar support for ExprIfLet in the ExprIf else position
-        ast::ExprIf(cond, blk, mut elseopt) => {
-            // NOTE: replace with 'if let' after snapshot
-            match elseopt {
-                Some(els) => match els.node {
-                    ast::ExprIfLet(..) => {
-                        // wrap the if-let expr in a block
-                        let blk = P(ast::Block {
-                            view_items: vec![],
-                            stmts: vec![],
-                            expr: Some(els),
-                            id: ast::DUMMY_NODE_ID,
-                            rules: ast::DefaultBlock,
-                            span: els.span
-                        });
-                        elseopt = Some(fld.cx.expr_block(blk));
-                    }
-                    _ => ()
-                },
-                None => ()
-            };
+        ast::ExprIf(cond, blk, elseopt) => {
+            let elseopt = elseopt.map(|els| match els.node {
+                ast::ExprIfLet(..) => {
+                    // wrap the if-let expr in a block
+                    let blk = P(ast::Block {
+                        view_items: vec![],
+                        stmts: vec![],
+                        expr: Some(els),
+                        id: ast::DUMMY_NODE_ID,
+                        rules: ast::DefaultBlock,
+                        span: els.span
+                    });
+                    fld.cx.expr_block(blk)
+                }
+                _ => els
+            });
             let if_expr = fld.cx.expr(e.span, ast::ExprIf(cond, blk, elseopt));
             noop_fold_expr(if_expr, fld)
         }

src/libsyntax/parse/parser.rs

@@ -572,7 +572,9 @@ impl<'a> Parser<'a> {
         if self.is_keyword(kw) {
             self.bump();
             true
-        } else { false }
+        } else {
+            false
+        }
     }
 
     /// If the given word is not a keyword, signal an error.
@@ -2739,7 +2741,9 @@ impl<'a> Parser<'a> {
         let thn = self.parse_block();
         let els = if self.eat_keyword(keywords::Else) {
             Some(self.parse_else_expr())
-        } else { None };
+        } else {
+            None
+        };
         let hi = els.map_or(thn.span.hi, |expr| expr.span.hi);
         self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els))
     }

src/libsyntax/print/pprust.rs

@@ -1489,7 +1489,7 @@ impl<'a> State<'a> {
                 try!(self.print_if(&**test, &**blk, elseopt));
             }
             ast::ExprIfLet(ref pat, ref expr, ref blk, elseopt) => {
-                try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt));
+                try!(self.print_if_let(&**pat, &**expr, &**blk, elseopt));
             }
             ast::ExprWhile(ref test, ref blk) => {
                 try!(self.head("while"));