---

yaml
---
r: 155579
b: refs/heads/try2
c: 49fcb27
h: refs/heads/master
i:
  155577: 13126d7
  155575: f846586
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 5f4c2800fcf0556b351857867e5b527af77149ee
+refs/heads/try2: 49fcb27df63b845c42d4883c47d2cfc512edeb78
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/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/try2/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/try2/src/etc/mklldeps.py

@@ -67,7 +67,7 @@ def run(args):
         "target_os = \"" + os + "\"",
     ]
 
-    f.write("#[cfg(" + ', '.join(cfg) + ")]\n")
+    f.write("#[cfg(all(" + ', '.join(cfg) + "))]\n")
 
     version = run([llconfig, '--version']).strip()
 

branches/try2/src/liballoc/heap.rs

@@ -111,12 +111,12 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
 // The minimum alignment guaranteed by the architecture. This value is used to
 // add fast paths for low alignment values. In practice, the alignment is a
 // constant at the call site and the branch will be optimized out.
-#[cfg(target_arch = "arm")]
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "arm",
+          target_arch = "mips",
+          target_arch = "mipsel"))]
 static MIN_ALIGN: uint = 8;
-#[cfg(target_arch = "x86")]
-#[cfg(target_arch = "x86_64")]
+#[cfg(any(target_arch = "x86",
+          target_arch = "x86_64"))]
 static MIN_ALIGN: uint = 16;
 
 #[cfg(jemalloc)]
@@ -146,7 +146,7 @@ mod imp {
     }
 
     // -lpthread needs to occur after -ljemalloc, the earlier argument isn't enough
-    #[cfg(not(windows), not(target_os = "android"))]
+    #[cfg(all(not(windows), not(target_os = "android")))]
     #[link(name = "pthread")]
     extern {}
 
@@ -206,7 +206,7 @@ mod imp {
     }
 }
 
-#[cfg(not(jemalloc), unix)]
+#[cfg(all(not(jemalloc), unix))]
 mod imp {
     use core::cmp;
     use core::ptr;
@@ -268,7 +268,7 @@ mod imp {
     pub fn stats_print() {}
 }
 
-#[cfg(not(jemalloc), windows)]
+#[cfg(all(not(jemalloc), windows))]
 mod imp {
     use libc::{c_void, size_t};
     use libc;

branches/try2/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/try2/src/libcore/any.rs

@@ -91,7 +91,7 @@ pub enum Void { }
 /// Every type with no non-`'static` references implements `Any`, so `Any` can
 /// be used as a trait object to emulate the effects dynamic typing.
 #[stable]
-pub trait Any: AnyPrivate {}
+pub trait Any: AnyPrivate + 'static {}
 
 /// An inner trait to ensure that only this module can call `get_type_id()`.
 pub trait AnyPrivate {
@@ -132,7 +132,7 @@ pub trait AnyRefExt<'a> {
 }
 
 #[stable]
-impl<'a> AnyRefExt<'a> for &'a Any+'a {
+impl<'a> AnyRefExt<'a> for &'a Any {
     #[inline]
     #[stable]
     fn is<T: 'static>(self) -> bool {
@@ -181,7 +181,7 @@ pub trait AnyMutRefExt<'a> {
 }
 
 #[stable]
-impl<'a> AnyMutRefExt<'a> for &'a mut Any+'a {
+impl<'a> AnyMutRefExt<'a> for &'a mut Any {
     #[inline]
     #[unstable = "naming conventions around acquiring references may change"]
     fn downcast_mut<T: 'static>(self) -> Option<&'a mut T> {

branches/try2/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/try2/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/try2/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/try2/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/try2/src/libgreen/basic.rs

@@ -116,7 +116,7 @@ impl EventLoop for BasicLoop {
             }
 
             unsafe {
-                let mut messages = self.messages.lock();
+                let messages = self.messages.lock();
                 // We block here if we have no messages to process and we may
                 // receive a message at a later date
                 if self.remotes.len() > 0 && messages.len() == 0 &&

branches/try2/src/libgreen/context.rs

@@ -188,27 +188,27 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
 
 // windows requires saving more registers (both general and XMM), so the windows
 // register context must be larger.
-#[cfg(windows, target_arch = "x86_64")]
+#[cfg(all(windows, target_arch = "x86_64"))]
 #[repr(C)]
 struct Registers {
     gpr:[libc::uintptr_t, ..14],
     _xmm:[simd::u32x4, ..10]
 }
-#[cfg(not(windows), target_arch = "x86_64")]
+#[cfg(all(not(windows), target_arch = "x86_64"))]
 #[repr(C)]
 struct Registers {
     gpr:[libc::uintptr_t, ..10],
     _xmm:[simd::u32x4, ..6]
 }
 
-#[cfg(windows, target_arch = "x86_64")]
+#[cfg(all(windows, target_arch = "x86_64"))]
 fn new_regs() -> Box<Registers> {
     box() Registers {
         gpr:[0,..14],
         _xmm:[simd::u32x4(0,0,0,0),..10]
     }
 }
-#[cfg(not(windows), target_arch = "x86_64")]
+#[cfg(all(not(windows), target_arch = "x86_64"))]
 fn new_regs() -> Box<Registers> {
     box() Registers {
         gpr:[0,..10],
@@ -288,16 +288,13 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
     regs[14] = rust_bootstrap_green_task as libc::uintptr_t;   // #56 pc, r14 --> lr
 }
 
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
 type Registers = [libc::uintptr_t, ..32];
 
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
 fn new_regs() -> Box<Registers> { box {[0, .. 32]} }
 
-#[cfg(target_arch = "mips")]
-#[cfg(target_arch = "mipsel")]
+#[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
 fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
                          procedure: raw::Procedure, sp: *mut uint) {
     let sp = align_down(sp);

branches/try2/src/libgreen/stack.rs

@@ -28,11 +28,10 @@ pub struct Stack {
 //
 // DragonFly BSD also seems to suffer from the same problem. When MAP_STACK is
 // used, it returns the same `ptr` multiple times.
-#[cfg(not(windows), not(target_os = "freebsd"), not(target_os = "dragonfly"))]
+#[cfg(not(any(windows, target_os = "freebsd", target_os = "dragonfly")))]
 static STACK_FLAGS: libc::c_int = libc::MAP_STACK | libc::MAP_PRIVATE |
                                   libc::MAP_ANON;
-#[cfg(target_os = "freebsd")]
-#[cfg(target_os = "dragonfly")]
+#[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
 static STACK_FLAGS: libc::c_int = libc::MAP_PRIVATE | libc::MAP_ANON;
 #[cfg(windows)]
 static STACK_FLAGS: libc::c_int = 0;