---

yaml
---
r: 126335
b: refs/heads/auto
c: 2a47fa7
h: refs/heads/master
i:
  126333: b8195a3
  126331: a2ac5d9
  126327: 59111c2
  126319: 9e432ec
  126303: 5fa1393
  126271: f2a1bdf
  126207: d3e12e8
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: c74d320662329922860c5cdaf8cba1797caebea4
+refs/heads/auto: 2a47fa708cfbf6b90a8ffacbaf00b8250bfa72cd
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -1647,14 +1647,14 @@ $ cargo build
 $
 ```
 
-Excellent! Open up your `src/guessing_game.rs` again. We'll be writing all of
+Excellent! Open up your `src/main.rs` again. We'll be writing all of
 our code in this file. We'll talk about multiple-file projects later on in the
 guide.
 
 ## Processing a Guess
 
 Let's get to it! The first thing we need to do for our guessing game is
-allow our player to input a guess. Put this in your `src/guessing_game.rs`:
+allow our player to input a guess. Put this in your `src/main.rs`:
 
 ```{rust,no_run}
 use std::io;
@@ -1734,9 +1734,9 @@ this using `cargo build`:
 ```{notrust,no_run}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:7:26: 7:34 error: the type of this value must be known in this context
-src/guessing_game.rs:7     let secret_number = (rand::random() % 100i) + 1i;
-                                                ^~~~~~~~
+src/main.rs:7:26: 7:34 error: the type of this value must be known in this context
+src/main.rs:7     let secret_number = (rand::random() % 100i) + 1i;
+                                       ^~~~~~~~
 error: aborting due to previous error
 ```
 
@@ -1896,12 +1896,12 @@ If we try to compile, we'll get some errors:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:20:15: 20:20 error: mismatched types: expected `int` but found `collections::string::String` (expected int but found struct collections::string::String)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                      ^~~~~
-src/guessing_game.rs:20:22: 20:35 error: mismatched types: expected `int` but found `uint` (expected int but found uint)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                             ^~~~~~~~~~~~~
+src/main.rs:20:15: 20:20 error: mismatched types: expected `int` but found `collections::string::String` (expected int but found struct collections::string::String)
+src/main.rs:20     match cmp(input, secret_number) {
+                             ^~~~~
+src/main.rs:20:22: 20:35 error: mismatched types: expected `int` but found `uint` (expected int but found uint)
+src/main.rs:20     match cmp(input, secret_number) {
+                                    ^~~~~~~~~~~~~
 error: aborting due to 2 previous errors
 ```
 
@@ -1950,9 +1950,9 @@ And try compiling again:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String)
-src/guessing_game.rs:20     match cmp(input, secret_number) {
-                                      ^~~~~
+src/main.rs:20:15: 20:20 error: mismatched types: expected `uint` but found `collections::string::String` (expected uint but found struct collections::string::String)
+src/main.rs:20     match cmp(input, secret_number) {
+                             ^~~~~
 error: aborting due to previous error
 ```
 
@@ -2053,9 +2053,9 @@ Let's try it out!
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
-src/guessing_game.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option)
-src/guessing_game.rs:22     match cmp(input_num, secret_number) {
-                                      ^~~~~~~~~
+src/main.rs:22:15: 22:24 error: mismatched types: expected `uint` but found `core::option::Option<uint>` (expected uint but found enum core::option::Option)
+src/main.rs:22     match cmp(input_num, secret_number) {
+                             ^~~~~~~~~
 error: aborting due to previous error
 ```
 

branches/auto/src/doc/intro.md

@@ -359,10 +359,11 @@ fn main() {
             // Take the lock, along with exclusive access to the underlying array
             let mut numbers = numbers_lock.lock();
 
-            // This is ugly for now, but will be replaced by
-            // `numbers[num as uint] += 1` in the near future.
+            // This is ugly for now because of the need for `get_mut`, but
+            // will be replaced by `numbers[num as uint] += 1`
+            // in the near future.
             // See: https://github.com/rust-lang/rust/issues/6515
-            *numbers.get_mut(num as uint) = *numbers.get_mut(num as uint) + 1;
+            *numbers.get_mut(num as uint) += 1;
 
             println!("{}", (*numbers)[num as uint]);
 

branches/auto/src/doc/rust.md

@@ -112,8 +112,7 @@ production. See [tokens](#tokens) for more information.
 
 ## Input format
 
-Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8,
-normalized to Unicode normalization form NFKC.
+Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8.
 Most Rust grammar rules are defined in terms of printable ASCII-range codepoints,
 but a small number are defined in terms of Unicode properties or explicit
 codepoint lists. [^inputformat]

branches/auto/src/doc/tutorial.md

@@ -2196,7 +2196,7 @@ and may not be overridden:
 Types are sendable
 unless they contain references.
 
-* `Share` - Types that are *threadsafe*
+* `Share` - Types that are *threadsafe*.
 These are types that are safe to be used across several threads with access to
 a `&T` pointer. `Mutex<T>` is an example of a *sharable* type with internal mutable data.
 

branches/auto/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -22,6 +22,7 @@
     <style id="number" _name="Number" map-to="def:number"/>
     <style id="scope" _name="Scope" map-to="def:preprocessor"/>
     <style id="attribute" _name="Attribute" map-to="def:preprocessor"/>
+    <style id="macro" _name="Macro" map-to="def:preprocessor"/>
   </styles>
 
   <definitions>
@@ -251,6 +252,12 @@
       </match>
     </context>
 
+    <context id="macro" style-ref="macro">
+      <match extended="true">
+        \%{ident}!
+      </match>
+    </context>
+
     <context id="lifetime" style-ref="keyword">
       <match extended="true">
         '\%{ident}
@@ -308,6 +315,7 @@
         <context ref="types"/>
         <context ref="ctypes"/>
         <context ref="self"/>
+        <context ref="macro"/>
         <context ref="constants"/>
         <context ref="cconstants"/>
         <context ref="line-comment"/>

branches/auto/src/liballoc/heap.rs

@@ -136,6 +136,9 @@ mod imp {
     use libc::{c_char, c_int, c_void, size_t};
 
     #[link(name = "jemalloc", kind = "static")]
+    #[cfg(not(test))]
+    extern {}
+
     extern {
         fn je_mallocx(size: size_t, flags: c_int) -> *mut c_void;
         fn je_rallocx(ptr: *mut c_void, size: size_t,

branches/auto/src/libcore/fmt/mod.rs

@@ -127,9 +127,9 @@ impl<'a> Arguments<'a> {
 /// to prevent modification.
 ///
 /// The `format_args!` macro will safely create an instance of this structure
-/// and pass it to a user-supplied function. The macro validates the format
-/// string at compile-time so usage of the `write` and `format` functions can
-/// be safely performed.
+/// and pass it to a function or closure, passed as the first argument. The
+/// macro validates the format string at compile-time so usage of the `write`
+/// and `format` functions can be safely performed.
 pub struct Arguments<'a> {
     fmt: &'a [rt::Piece<'a>],
     args: &'a [Argument<'a>],

branches/auto/src/libcore/slice.rs

@@ -76,6 +76,16 @@ pub trait ImmutableVector<'a, T> {
      * Fails when `end` points outside the bounds of self.
      */
     fn slice_to(&self, end: uint) -> &'a [T];
+
+    /// Divides one slice into two at an index.
+    ///
+    /// The first will contain all indices from `[0, mid)` (excluding
+    /// the index `mid` itself) and the second will contain all
+    /// indices from `[mid, len)` (excluding the index `len` itself).
+    ///
+    /// Fails if `mid > len`.
+    fn split_at(&self, mid: uint) -> (&'a [T], &'a [T]);
+
     /// Returns an iterator over the vector
     fn iter(self) -> Items<'a, T>;
     /// Returns an iterator over the subslices of the vector which are
@@ -247,6 +257,11 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
         self.slice(0, end)
     }
 
+    #[inline]
+    fn split_at(&self, mid: uint) -> (&'a [T], &'a [T]) {
+        (self.slice(0, mid), self.slice(mid, self.len()))
+    }
+
     #[inline]
     fn iter(self) -> Items<'a, T> {
         unsafe {
@@ -1192,8 +1207,7 @@ impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
             None
         } else {
             let chunksz = cmp::min(self.v.len(), self.size);
-            let (fst, snd) = (self.v.slice_to(chunksz),
-                              self.v.slice_from(chunksz));
+            let (fst, snd) = self.v.split_at(chunksz);
             self.v = snd;
             Some(fst)
         }
@@ -1219,8 +1233,7 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
         } else {
             let remainder = self.v.len() % self.size;
             let chunksz = if remainder != 0 { remainder } else { self.size };
-            let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
-                              self.v.slice_from(self.v.len() - chunksz));
+            let (fst, snd) = self.v.split_at(self.v.len() - chunksz);
             self.v = fst;
             Some(snd)
         }

branches/auto/src/libfourcc/lib.rs

@@ -124,7 +124,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
             (val << 8) | (byte as u32)
         };
     }
-    let e = cx.expr_lit(sp, ast::LitUint(val as u64, ast::TyU32));
+    let e = cx.expr_lit(sp, ast::LitInt(val as u64, ast::UnsignedIntLit(ast::TyU32)));
     MacExpr::new(e)
 }
 

branches/auto/src/libnative/io/file_win32.rs

@@ -516,8 +516,8 @@ pub fn lstat(_p: &CString) -> IoResult<rtio::FileStat> {
 
 pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
     let mut buf = libc::utimbuf {
-        actime: (atime / 1000) as libc::time64_t,
-        modtime: (mtime / 1000) as libc::time64_t,
+        actime: atime as libc::time64_t,
+        modtime: mtime as libc::time64_t,
     };
     let p = try!(to_utf16(p));
     super::mkerr_libc(unsafe {

branches/auto/src/libnative/io/net.rs

@@ -66,26 +66,27 @@ fn ip_to_inaddr(ip: rtio::IpAddr) -> InAddr {
     }
 }
 
-fn addr_to_sockaddr(addr: rtio::SocketAddr) -> (libc::sockaddr_storage, uint) {
+fn addr_to_sockaddr(addr: rtio::SocketAddr,
+                    storage: &mut libc::sockaddr_storage)
+                    -> libc::socklen_t {
     unsafe {
-        let storage: libc::sockaddr_storage = mem::zeroed();
         let len = match ip_to_inaddr(addr.ip) {
             InAddr(inaddr) => {
-                let storage: *mut libc::sockaddr_in = mem::transmute(&storage);
+                let storage = storage as *mut _ as *mut libc::sockaddr_in;
                 (*storage).sin_family = libc::AF_INET as libc::sa_family_t;
                 (*storage).sin_port = htons(addr.port);
                 (*storage).sin_addr = inaddr;
                 mem::size_of::<libc::sockaddr_in>()
             }
             In6Addr(inaddr) => {
-                let storage: *mut libc::sockaddr_in6 = mem::transmute(&storage);
+                let storage = storage as *mut _ as *mut libc::sockaddr_in6;
                 (*storage).sin6_family = libc::AF_INET6 as libc::sa_family_t;
                 (*storage).sin6_port = htons(addr.port);
                 (*storage).sin6_addr = inaddr;
                 mem::size_of::<libc::sockaddr_in6>()
             }
         };
-        return (storage, len);
+        return len as libc::socklen_t;
     }
 }
 
@@ -277,9 +278,9 @@ impl TcpStream {
         let fd = try!(socket(addr, libc::SOCK_STREAM));
         let ret = TcpStream::new(Inner::new(fd));
 
-        let (addr, len) = addr_to_sockaddr(addr);
-        let addrp = &addr as *const _ as *const libc::sockaddr;
-        let len = len as libc::socklen_t;
+        let mut storage = unsafe { mem::zeroed() };
+        let len = addr_to_sockaddr(addr, &mut storage);
+        let addrp = &storage as *const _ as *const libc::sockaddr;
 
         match timeout {
             Some(timeout) => {
@@ -457,9 +458,9 @@ impl TcpListener {
         let fd = try!(socket(addr, libc::SOCK_STREAM));
         let ret = TcpListener { inner: Inner::new(fd) };
 
-        let (addr, len) = addr_to_sockaddr(addr);
-        let addrp = &addr as *const _ as *const libc::sockaddr;
-        let len = len as libc::socklen_t;
+        let mut storage = unsafe { mem::zeroed() };
+        let len = addr_to_sockaddr(addr, &mut storage);
+        let addrp = &storage as *const _ as *const libc::sockaddr;
 
         // On platforms with Berkeley-derived sockets, this allows
         // to quickly rebind a socket, without needing to wait for
@@ -566,9 +567,9 @@ impl UdpSocket {
             write_deadline: 0,
         };
 
-        let (addr, len) = addr_to_sockaddr(addr);
-        let addrp = &addr as *const _ as *const libc::sockaddr;
-        let len = len as libc::socklen_t;
+        let mut storage = unsafe { mem::zeroed() };
+        let len = addr_to_sockaddr(addr, &mut storage);
+        let addrp = &storage as *const _ as *const libc::sockaddr;
 
         match unsafe { libc::bind(fd, addrp, len) } {
             -1 => Err(last_error()),
@@ -656,9 +657,9 @@ impl rtio::RtioUdpSocket for UdpSocket {
     }
 
     fn send_to(&mut self, buf: &[u8], dst: rtio::SocketAddr) -> IoResult<()> {
-        let (dst, dstlen) = addr_to_sockaddr(dst);
-        let dstp = &dst as *const _ as *const libc::sockaddr;
-        let dstlen = dstlen as libc::socklen_t;
+        let mut storage = unsafe { mem::zeroed() };
+        let dstlen = addr_to_sockaddr(dst, &mut storage);
+        let dstp = &storage as *const _ as *const libc::sockaddr;
 
         let fd = self.fd();
         let dolock = || self.lock_nonblocking();

branches/auto/src/libnative/io/pipe_unix.rs

@@ -29,12 +29,13 @@ fn unix_socket(ty: libc::c_int) -> IoResult<fd_t> {
     }
 }
 
-fn addr_to_sockaddr_un(addr: &CString) -> IoResult<(libc::sockaddr_storage, uint)> {
+fn addr_to_sockaddr_un(addr: &CString,
+                       storage: &mut libc::sockaddr_storage)
+                       -> IoResult<libc::socklen_t> {
     // the sun_path length is limited to SUN_LEN (with null)
     assert!(mem::size_of::<libc::sockaddr_storage>() >=
             mem::size_of::<libc::sockaddr_un>());
-    let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
-    let s: &mut libc::sockaddr_un = unsafe { mem::transmute(&mut storage) };
+    let s = unsafe { &mut *(storage as *mut _ as *mut libc::sockaddr_un) };
 
     let len = addr.len();
     if len > s.sun_path.len() - 1 {
@@ -53,7 +54,7 @@ fn addr_to_sockaddr_un(addr: &CString) -> IoResult<(libc::sockaddr_storage, uint
 
     // count the null terminator
     let len = mem::size_of::<libc::sa_family_t>() + len + 1;
-    return Ok((storage, len));
+    return Ok(len as libc::socklen_t);
 }
 
 struct Inner {
@@ -76,10 +77,10 @@ impl Drop for Inner {
 
 fn connect(addr: &CString, ty: libc::c_int,
            timeout: Option<u64>) -> IoResult<Inner> {
-    let (addr, len) = try!(addr_to_sockaddr_un(addr));
+    let mut storage = unsafe { mem::zeroed() };
+    let len = try!(addr_to_sockaddr_un(addr, &mut storage));
     let inner = Inner::new(try!(unix_socket(ty)));
-    let addrp = &addr as *const _ as *const libc::sockaddr;
-    let len = len as libc::socklen_t;
+    let addrp = &storage as *const _ as *const libc::sockaddr;
 
     match timeout {
         None => {
@@ -96,11 +97,12 @@ fn connect(addr: &CString, ty: libc::c_int,
 }
 
 fn bind(addr: &CString, ty: libc::c_int) -> IoResult<Inner> {
-    let (addr, len) = try!(addr_to_sockaddr_un(addr));
+    let mut storage = unsafe { mem::zeroed() };
+    let len = try!(addr_to_sockaddr_un(addr, &mut storage));
     let inner = Inner::new(try!(unix_socket(ty)));
-    let addrp = &addr as *const _;
+    let addrp = &storage as *const _ as *const libc::sockaddr;
     match unsafe {
-        libc::bind(inner.fd, addrp as *const _, len as libc::socklen_t)
+        libc::bind(inner.fd, addrp, len)
     } {
         -1 => Err(super::last_error()),
         _  => Ok(inner)