---

yaml
---
r: 154087
b: refs/heads/try2
c: c74d320
h: refs/heads/master
i:
  154085: c84b041
  154083: ae09c31
  154079: 5bbb590
v: v3

Author: conradkleinespel

[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: f5ac41185a821681f4bfaf93ef0569955d24ef4a
+refs/heads/try2: c74d320662329922860c5cdaf8cba1797caebea4
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide.md

@@ -1647,14 +1647,14 @@ $ cargo build
 $
 ```
 
-Excellent! Open up your `src/main.rs` again. We'll be writing all of
+Excellent! Open up your `src/guessing_game.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/main.rs`:
+allow our player to input a guess. Put this in your `src/guessing_game.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/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;
-                                       ^~~~~~~~
+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;
+                                                ^~~~~~~~
 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/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) {
-                                    ^~~~~~~~~~~~~
+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) {
+                                             ^~~~~~~~~~~~~
 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/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) {
-                             ^~~~~
+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) {
+                                      ^~~~~
 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/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) {
-                             ^~~~~~~~~
+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) {
+                                      ^~~~~~~~~
 error: aborting due to previous error
 ```
 

branches/try2/src/doc/intro.md

@@ -359,11 +359,10 @@ fn main() {
             // Take the lock, along with exclusive access to the underlying array
             let mut numbers = numbers_lock.lock();
 
-            // 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.
+            // This is ugly for now, 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) += 1;
+            *numbers.get_mut(num as uint) = *numbers.get_mut(num as uint) + 1;
 
             println!("{}", (*numbers)[num as uint]);
 

branches/try2/src/doc/rust.md

@@ -112,7 +112,8 @@ production. See [tokens](#tokens) for more information.
 
 ## Input format
 
-Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8.
+Rust input is interpreted as a sequence of Unicode codepoints encoded in UTF-8,
+normalized to Unicode normalization form NFKC.
 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/try2/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/try2/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -22,7 +22,6 @@
     <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>
@@ -252,12 +251,6 @@
       </match>
     </context>
 
-    <context id="macro" style-ref="macro">
-      <match extended="true">
-        \%{ident}!
-      </match>
-    </context>
-
     <context id="lifetime" style-ref="keyword">
       <match extended="true">
         '\%{ident}
@@ -315,7 +308,6 @@
         <context ref="types"/>
         <context ref="ctypes"/>
         <context ref="self"/>
-        <context ref="macro"/>
         <context ref="constants"/>
         <context ref="cconstants"/>
         <context ref="line-comment"/>

branches/try2/src/liballoc/heap.rs

@@ -136,9 +136,6 @@ 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/try2/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 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.
+/// 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.
 pub struct Arguments<'a> {
     fmt: &'a [rt::Piece<'a>],
     args: &'a [Argument<'a>],

branches/try2/src/libcore/slice.rs

@@ -76,16 +76,6 @@ 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
@@ -257,11 +247,6 @@ 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 {
@@ -1207,7 +1192,8 @@ 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.split_at(chunksz);
+            let (fst, snd) = (self.v.slice_to(chunksz),
+                              self.v.slice_from(chunksz));
             self.v = snd;
             Some(fst)
         }
@@ -1233,7 +1219,8 @@ 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.split_at(self.v.len() - chunksz);
+            let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
+                              self.v.slice_from(self.v.len() - chunksz));
             self.v = fst;
             Some(snd)
         }

branches/try2/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::LitInt(val as u64, ast::UnsignedIntLit(ast::TyU32)));
+    let e = cx.expr_lit(sp, ast::LitUint(val as u64, ast::TyU32));
     MacExpr::new(e)
 }
 

branches/try2/src/libgetopts/lib.rs

@@ -115,9 +115,9 @@ pub enum Name {
 pub enum HasArg {
     /// The option requires an argument.
     Yes,
-    /// The option is just a flag, therefore no argument.
+    /// The option takes no argument.
     No,
-    /// The option argument is optional and it could or not exist.
+    /// The option argument is optional.
     Maybe,
 }
 
@@ -126,9 +126,9 @@ pub enum HasArg {
 pub enum Occur {
     /// The option occurs once.
     Req,
-    /// The option could or not occur.
+    /// The option occurs at most once.
     Optional,
-    /// The option occurs once or multiple times.
+    /// The option occurs zero or more times.
     Multi,
 }
 

branches/try2/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 as libc::time64_t,
-        modtime: mtime as libc::time64_t,
+        actime: (atime / 1000) as libc::time64_t,
+        modtime: (mtime / 1000) as libc::time64_t,
     };
     let p = try!(to_utf16(p));
     super::mkerr_libc(unsafe {

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

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