---

yaml
---
r: 136831
b: refs/heads/dist-snap
c: fe93a54
h: refs/heads/master
i:
  136829: 695d3f9
  136827: 9edbc2a
  136823: d07ea4a
  136815: abd238f
  136799: 3bb960d
  136767: 353aa33
  136703: b8daa17
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 189b7332968972f34cdbbbd9b62d97ababf53059
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 0cf60b6bb8fed2cad4407fdf86a49a7eebbd62e6
+refs/heads/dist-snap: fe93a549a49983837747986797a40d85ba047cad
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/compiletest/runtest.rs

@@ -1512,7 +1512,7 @@ fn _arm_exec_compiled_test(config: &Config,
     for c in exitcode_out.as_slice().chars() {
         if !c.is_digit() { break; }
         exitcode = exitcode * 10 + match c {
-            '0' .. '9' => c as int - ('0' as int),
+            '0' ... '9' => c as int - ('0' as int),
             _ => 101,
         }
     }

branches/dist-snap/src/doc/guide.md

@@ -3757,27 +3757,27 @@ match x {
 }
 ```
 
-You can match a range of values with `..`:
+You can match a range of values with `...`:
 
 ```{rust}
 let x = 1i;
 
 match x {
-    1 .. 5 => println!("one through five"),
+    1 ... 5 => println!("one through five"),
     _ => println!("anything"),
 }
 ```
 
 Ranges are mostly used with integers and single characters.
 
-If you're matching multiple things, via a `|` or a `..`, you can bind
+If you're matching multiple things, via a `|` or a `...`, you can bind
 the value to a name with `@`:
 
 ```{rust}
 let x = 1i;
 
 match x {
-    x @ 1 .. 5 => println!("got {}", x),
+    x @ 1 ... 5 => println!("got {}", x),
     _ => println!("anything"),
 }
 ```

branches/dist-snap/src/doc/reference.md

@@ -2441,6 +2441,8 @@ The currently implemented features of the reference compiler are:
 * `default_type_params` - Allows use of default type parameters. The future of
                           this feature is uncertain.
 
+* `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.
 
@@ -3229,7 +3231,7 @@ for i in range(0u, 256) {
 if_expr : "if" no_struct_literal_expr '{' block '}'
           else_tail ? ;
 
-else_tail : "else" [ if_expr
+else_tail : "else" [ if_expr | if_let_expr
                    | '{' block '}' ] ;
 ```
 
@@ -3408,7 +3410,7 @@ may be specified with `..`. For example:
 
 let message = match x {
   0 | 1  => "not many",
-  2 .. 9 => "a few",
+  2 ... 9 => "a few",
   _      => "lots"
 };
 ```
@@ -3434,6 +3436,19 @@ let message = match maybe_digit {
 };
 ```
 
+### If let expressions
+
+```{.ebnf .gram}
+if_let_expr : "if" "let" pat '=' expr '{' block '}'
+               else_tail ? ;
+else_tail : "else" [ if_expr | if_let_expr | '{' block '}' ] ;
+```
+
+An `if let` expression is semantically identical to an `if` expression but in place
+of a condition expression it expects a refutable let statement. If the value of the
+expression on the right hand side of the let statement matches the pattern, the corresponding
+block will execute, otherwise flow proceeds to the first `else` block that follows.
+
 ### Return expressions
 
 ```{.ebnf .gram}

branches/dist-snap/src/libcollections/string.rs

@@ -199,10 +199,10 @@ impl String {
                     }
                     3 => {
                         match (byte, safe_get(v, i, total)) {
-                            (0xE0        , 0xA0 .. 0xBF) => (),
-                            (0xE1 .. 0xEC, 0x80 .. 0xBF) => (),
-                            (0xED        , 0x80 .. 0x9F) => (),
-                            (0xEE .. 0xEF, 0x80 .. 0xBF) => (),
+                            (0xE0         , 0xA0 ... 0xBF) => (),
+                            (0xE1 ... 0xEC, 0x80 ... 0xBF) => (),
+                            (0xED         , 0x80 ... 0x9F) => (),
+                            (0xEE ... 0xEF, 0x80 ... 0xBF) => (),
                             _ => {
                                 error!();
                                 continue;
@@ -217,9 +217,9 @@ impl String {
                     }
                     4 => {
                         match (byte, safe_get(v, i, total)) {
-                            (0xF0        , 0x90 .. 0xBF) => (),
-                            (0xF1 .. 0xF3, 0x80 .. 0xBF) => (),
-                            (0xF4        , 0x80 .. 0x8F) => (),
+                            (0xF0         , 0x90 ... 0xBF) => (),
+                            (0xF1 ... 0xF3, 0x80 ... 0xBF) => (),
+                            (0xF4         , 0x80 ... 0x8F) => (),
                             _ => {
                                 error!();
                                 continue;

branches/dist-snap/src/libcore/char.rs

@@ -123,9 +123,9 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
         fail!("to_digit: radix is too high (maximum 36)");
     }
     let val = match c {
-      '0' .. '9' => c as uint - ('0' as uint),
-      'a' .. 'z' => c as uint + 10u - ('a' as uint),
-      'A' .. 'Z' => c as uint + 10u - ('A' as uint),
+      '0' ... '9' => c as uint - ('0' as uint),
+      'a' ... 'z' => c as uint + 10u - ('a' as uint),
+      'A' ... 'Z' => c as uint + 10u - ('A' as uint),
       _ => return None,
     };
     if val < radix { Some(val) }
@@ -184,7 +184,7 @@ pub fn escape_unicode(c: char, f: |char|) {
         let offset = offset as uint;
         unsafe {
             match ((c as i32) >> offset) & 0xf {
-                i @ 0 .. 9 => { f(transmute('0' as i32 + i)); }
+                i @ 0 ... 9 => { f(transmute('0' as i32 + i)); }
                 i => { f(transmute('a' as i32 + (i - 10))); }
             }
         }
@@ -211,7 +211,7 @@ pub fn escape_default(c: char, f: |char|) {
         '\\' => { f('\\'); f('\\'); }
         '\'' => { f('\\'); f('\''); }
         '"'  => { f('\\'); f('"'); }
-        '\x20' .. '\x7e' => { f(c); }
+        '\x20' ... '\x7e' => { f(c); }
         _ => c.escape_unicode(f),
     }
 }

branches/dist-snap/src/libcore/fmt/num.rs

@@ -99,13 +99,13 @@ macro_rules! radix {
     }
 }
 
-radix!(Binary,    2, "0b", x @  0 .. 2 => b'0' + x)
-radix!(Octal,     8, "0o", x @  0 .. 7 => b'0' + x)
-radix!(Decimal,  10, "",   x @  0 .. 9 => b'0' + x)
-radix!(LowerHex, 16, "0x", x @  0 .. 9 => b'0' + x,
-                           x @ 10 ..15 => b'a' + (x - 10))
-radix!(UpperHex, 16, "0x", x @  0 .. 9 => b'0' + x,
-                           x @ 10 ..15 => b'A' + (x - 10))
+radix!(Binary,    2, "0b", x @  0 ...  2 => b'0' + x)
+radix!(Octal,     8, "0o", x @  0 ...  7 => b'0' + x)
+radix!(Decimal,  10, "",   x @  0 ...  9 => b'0' + x)
+radix!(LowerHex, 16, "0x", x @  0 ...  9 => b'0' + x,
+                           x @ 10 ... 15 => b'a' + (x - 10))
+radix!(UpperHex, 16, "0x", x @  0 ...  9 => b'0' + x,
+                           x @ 10 ... 15 => b'A' + (x - 10))
 
 /// A radix with in the range of `2..36`.
 #[deriving(Clone, PartialEq)]
@@ -124,7 +124,7 @@ impl GenericRadix for Radix {
     fn base(&self) -> u8 { self.base }
     fn digit(&self, x: u8) -> u8 {
         match x {
-            x @  0 ..9 => b'0' + x,
+            x @  0 ... 9 => b'0' + x,
             x if x < self.base() => b'a' + (x - 10),
             x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
         }

branches/dist-snap/src/libcore/str.rs

@@ -843,18 +843,18 @@ fn run_utf8_validation_iterator(iter: &mut slice::Items<u8>) -> bool {
                 2 => if second & !CONT_MASK != TAG_CONT_U8 {err!()},
                 3 => {
                     match (first, second, next!() & !CONT_MASK) {
-                        (0xE0        , 0xA0 .. 0xBF, TAG_CONT_U8) |
-                        (0xE1 .. 0xEC, 0x80 .. 0xBF, TAG_CONT_U8) |
-                        (0xED        , 0x80 .. 0x9F, TAG_CONT_U8) |
-                        (0xEE .. 0xEF, 0x80 .. 0xBF, TAG_CONT_U8) => {}
+                        (0xE0         , 0xA0 ... 0xBF, TAG_CONT_U8) |
+                        (0xE1 ... 0xEC, 0x80 ... 0xBF, TAG_CONT_U8) |
+                        (0xED         , 0x80 ... 0x9F, TAG_CONT_U8) |
+                        (0xEE ... 0xEF, 0x80 ... 0xBF, TAG_CONT_U8) => {}
                         _ => err!()
                     }
                 }
                 4 => {
                     match (first, second, next!() & !CONT_MASK, next!() & !CONT_MASK) {
-                        (0xF0        , 0x90 .. 0xBF, TAG_CONT_U8, TAG_CONT_U8) |
-                        (0xF1 .. 0xF3, 0x80 .. 0xBF, TAG_CONT_U8, TAG_CONT_U8) |
-                        (0xF4        , 0x80 .. 0x8F, TAG_CONT_U8, TAG_CONT_U8) => {}
+                        (0xF0         , 0x90 ... 0xBF, TAG_CONT_U8, TAG_CONT_U8) |
+                        (0xF1 ... 0xF3, 0x80 ... 0xBF, TAG_CONT_U8, TAG_CONT_U8) |
+                        (0xF4         , 0x80 ... 0x8F, TAG_CONT_U8, TAG_CONT_U8) => {}
                         _ => err!()
                     }
                 }

branches/dist-snap/src/libdebug/repr.rs

@@ -227,7 +227,7 @@ impl<'a> ReprVisitor<'a> {
                     self.writer.write("\"".as_bytes())
                 }
             }
-            '\x20'..'\x7e' => self.writer.write([ch as u8]),
+            '\x20'...'\x7e' => self.writer.write([ch as u8]),
             _ => {
                 char::escape_unicode(ch, |c| {
                     let _ = self.writer.write([c as u8]);

branches/dist-snap/src/libnative/io/tty_windows.rs

@@ -67,7 +67,7 @@ impl WindowsTTY {
         // If the file descriptor is one of stdin, stderr, or stdout
         // then it should not be closed by us
         let closeme = match fd {
-            0..2 => false,
+            0...2 => false,
             _ => true,
         };
         let handle = unsafe { get_osfhandle(fd) as HANDLE };

branches/dist-snap/src/librand/distributions/gamma.rs

@@ -98,9 +98,9 @@ impl Gamma {
         assert!(scale > 0.0, "Gamma::new called with scale <= 0");
 
         let repr = match shape {
-            1.0        => One(Exp::new(1.0 / scale)),
-            0.0 .. 1.0 => Small(GammaSmallShape::new_raw(shape, scale)),
-            _          => Large(GammaLargeShape::new_raw(shape, scale))
+            1.0         => One(Exp::new(1.0 / scale)),
+            0.0 ... 1.0 => Small(GammaSmallShape::new_raw(shape, scale)),
+            _           => Large(GammaLargeShape::new_raw(shape, scale))
         };
         Gamma { repr: repr }
     }

branches/dist-snap/src/libregex/vm.rs

@@ -512,7 +512,7 @@ pub fn is_word(c: Option<char>) -> bool {
     };
     // Try the common ASCII case before invoking binary search.
     match c {
-        '_' | '0' .. '9' | 'a' .. 'z' | 'A' .. 'Z' => true,
+        '_' | '0' ... '9' | 'a' ... 'z' | 'A' ... 'Z' => true,
         _ => PERLW.binary_search(|&(start, end)| {
             if c >= start && c <= end {
                 Equal

branches/dist-snap/src/librustc/back/link.rs

@@ -277,9 +277,9 @@ pub fn sanitize(s: &str) -> String {
             '-' | ':' => result.push_char('.'),
 
             // These are legal symbols
-            'a' .. 'z'
-            | 'A' .. 'Z'
-            | '0' .. '9'
+            'a' ... 'z'
+            | 'A' ... 'Z'
+            | '0' ... '9'
             | '_' | '.' | '$' => result.push_char(c),
 
             _ => {

branches/dist-snap/src/librustc/diagnostics.rs

@@ -151,5 +151,6 @@ register_diagnostics!(
     E0157,
     E0158,
     E0159,
-    E0161
+    E0161,
+    E0162
 )

branches/dist-snap/src/librustc/lint/builtin.rs

@@ -1092,7 +1092,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),
@@ -1242,7 +1245,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())
                 }

branches/dist-snap/src/librustc/middle/cfg/construct.rs

@@ -222,6 +222,10 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 self.add_node(expr.id, [then_exit, else_exit])           // 4, 5
             }
 
+            ast::ExprIfLet(..) => {
+                self.tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+            }
+
             ast::ExprWhile(ref cond, ref body, _) => {
                 //
                 //         [pred]
@@ -322,7 +326,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 expr_exit
             }
 
-            ast::ExprMatch(ref discr, ref arms) => {
+            ast::ExprMatch(ref discr, ref arms, _) => {
                 //
                 //     [pred]
                 //       |

branches/dist-snap/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];
+                            let first_pat = first_arm_pats.get(0);
+                            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!()
             }

branches/dist-snap/src/librustc/middle/expr_use_visitor.rs

@@ -374,7 +374,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
                 }
             }
 
-            ast::ExprMatch(ref discr, ref arms) => {
+            ast::ExprIfLet(..) => {
+                self.tcx().sess.span_bug(expr.span, "non-desugared ExprIfLet");
+            }
+
+            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);