---

yaml
---
r: 109835
b: refs/heads/master
c: 3b4a517
h: refs/heads/master
i:
  109833: 7ecbf7e
  109831: 53f98e6
v: v3

Author: emberian

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7bda3df6ff894e9b522ede02b15b6772c99e7362
+refs/heads/master: 3b4a5174c099b38fc1e71599540d13193de2467c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c7fac4471201977fdb1c0c0a26c87287e12dc644
 refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d

trunk/RELEASES.txt

@@ -6,10 +6,7 @@ Version 0.10 (April 2014)
   * Language
     * A new RFC process is now in place for modifying the language.
     * Patterns with `@`-pointers have been removed from the language.
-    * Patterns with unique vectors (`~[T]`) have been removed from the
-      language.
-    * Patterns with unique strings (`~str`) have been removed from the
-      language.
+    * Patterns with unique vectors have been removed from the language.
     * `@str` has been removed from the language.
     * `@[T]` has been removed from the language.
     * `@self` has been removed from the language.
@@ -28,10 +25,9 @@ Version 0.10 (April 2014)
       * Camel Case types
       * Uppercase variables
       * Publicly visible private types
-      * `#[deriving]` with raw pointers
     * Unsafe functions can no longer be coerced to closures.
     * Various obscure macros such as `log_syntax!` are now behind feature gates.
-    * The `#[simd]` attribute is now behind a feature gate.
+    * The #[simd] attribute is now behind a feature gate.
     * Visibility is no longer allowed on `extern crate` statements, and
       unnecessary visibility (`priv`) is no longer allowed on `use` statements.
     * Trailing commas are now allowed in argument lists and tuple patterns.
@@ -43,7 +39,7 @@ Version 0.10 (April 2014)
     * The `Share` trait has been added for types that can be shared among
       threads.
     * Labels in macros are now hygienic.
-    * Expression/statement macro invocations can be delimited with `{}` now.
+    * Expresson/statement macro invocations can be delimited with `{}` now.
     * Treatment of types allowed in `static mut` locations has been tweaked.
     * The `*` and `.` operators are now overloadable through the `Deref` and
       `DerefMut` traits.
@@ -136,7 +132,7 @@ Version 0.10 (April 2014)
   * Tooling
     * `rustpkg` has been deprecated and removed from the main repository. Its
       replacement, `cargo`, is under development.
-    * Nightly builds of rust are now available
+    * Nightly builds of rust are now available (INSERT URL HERE)
     * The memory usage of rustc has been improved many times throughout this
       release cycle.
     * The build process supports disabling rpath support for the rustc binary
@@ -149,20 +145,16 @@ Version 0.10 (April 2014)
     * Output flags have been centralized into one `--emit` flag.
     * Crate type flags have been centralized into one `--crate-type` flag.
     * Codegen flags have been consolidated behind a `-C` flag.
+    * `rustdoc` now implements syntax highlighting and rendering markdown files.
+    * `rustdoc --test` now tests all code blocks by default.
+    * `rustdoc` now shows documented macros.
+    * `rustdoc` inlines documentation for reexported types.
+    * `rustdoc` search works across crates now.
     * Linking against outdated crates now has improved error messages.
     * Error messages with lifetimes will often suggest how to annotate the
       function to fix the error.
     * Many more types are documented in the standard library, and new guides
       were written.
-    * Many `rustdoc` improvements:
-      * code blocks are syntax highlighted.
-      * render standalone markdown files.
-      * the --test flag tests all code blocks by default.
-      * exported macros are displayed.
-      * reexported types have their documentation inlined at the location of the
-        first reexport.
-      * search works across crates that have been rendered to the same output
-        directory.
 
 Version 0.9 (January 2014)
 --------------------------

trunk/src/doc/complement-lang-faq.md

@@ -31,10 +31,10 @@ You may also be interested in browsing [GitHub's Rust][github-rust] page.
 
 ## Does it run on Windows?
 
-Yes. All development happens in lock-step on all 3 target platforms. Using MinGW, not Cygwin. Note that the windows implementation currently has some limitations: in particular 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depends on libgcc DLL at runtime][libgcc].
+Yes. All development happens in lock-step on all 3 target platforms. Using MinGW, not Cygwin. Note that the windows implementation currently has some limitations: in particular tasks [cannot unwind on windows][unwind], and all Rust executables [require a MinGW installation at runtime][libgcc].
 
-[win64]: https://github.com/mozilla/rust/issues/1237
-[libgcc]: https://github.com/mozilla/rust/issues/11782
+[unwind]: https://github.com/mozilla/rust/issues/908
+[libgcc]: https://github.com/mozilla/rust/issues/1603
 
 ## Is it OO? How do I do this thing I normally do in an OO language?
 

trunk/src/doc/guide-pointers.md

@@ -332,6 +332,8 @@ sense, they're simple: just keep whatever ownership the data already has. For
 example:
 
 ~~~rust
+use std::num::sqrt;
+
 struct Point {
     x: f32,
     y: f32,
@@ -341,7 +343,7 @@ fn compute_distance(p1: &Point, p2: &Point) -> f32 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
 
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 
 fn main() {

trunk/src/doc/guide-runtime.md

@@ -216,7 +216,8 @@ into the pool of schedulers in order to spawn a new task.
 
 With two implementations of the runtime available, a choice obviously needs to
 be made to see which will be used. The compiler itself will always by-default
-link to one of these runtimes.
+link to one of these runtimes. At the time of this writing, the default runtime
+is `libgreen` but in the future this will become `libnative`.
 
 Having a default decision made in the compiler is done out of necessity and
 convenience. The compiler's decision of runtime to link to is *not* an

trunk/src/doc/rust.md

@@ -826,14 +826,14 @@ Use declarations support a number of convenient shortcuts:
 An example of `use` declarations:
 
 ~~~~
-use std::iter::range_step;
+use std::num::sin;
 use std::option::{Some, None};
 
 # fn foo<T>(_: T){}
 
 fn main() {
-    // Equivalent to 'std::iter::range_step(0, 10, 2);'
-    range_step(0, 10, 2);
+    // Equivalent to 'std::num::sin(1.0);'
+    sin(1.0);
 
     // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
     foo(~[Some(1.0), None]);

trunk/src/doc/tutorial.md

@@ -504,12 +504,13 @@ matching in order to bind names to the contents of data types.
 
 ~~~~
 use std::f64;
+use std::num::atan;
 fn angle(vector: (f64, f64)) -> f64 {
     let pi = f64::consts::PI;
     match vector {
       (0.0, y) if y < 0.0 => 1.5 * pi,
       (0.0, _) => 0.5 * pi,
-      (x, y) => (y / x).atan()
+      (x, y) => atan(y / x)
     }
 }
 ~~~~
@@ -1429,11 +1430,12 @@ bad, but often copies are expensive. So we’d like to define a function
 that takes the points by pointer. We can use references to do this:
 
 ~~~
+use std::num::sqrt;
 # struct Point { x: f64, y: f64 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 ~~~
 
@@ -2301,7 +2303,7 @@ impl Shape for Circle {
     fn new(area: f64) -> Circle { Circle { radius: (area / PI).sqrt() } }
 }
 impl Shape for Square {
-    fn new(area: f64) -> Square { Square { length: area.sqrt() } }
+    fn new(area: f64) -> Square { Square { length: (area).sqrt() } }
 }
 
 let area = 42.5;

trunk/src/libcollections/deque.rs

@@ -52,7 +52,7 @@ pub mod bench {
                                                   map: &mut M,
                                                   bh: &mut BenchHarness) {
         // setup
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::XorShiftRng::new();
 
         map.clear();
         for _ in range(0, n) {
@@ -89,7 +89,7 @@ pub mod bench {
                                                 map: &mut M,
                                                 bh: &mut BenchHarness) {
         // setup
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::XorShiftRng::new();
         let mut keys = slice::from_fn(n, |_| rng.gen::<uint>() % n);
 
         for k in keys.iter() {

trunk/src/libcollections/hashmap.rs

@@ -1600,12 +1600,12 @@ mod test_map {
 
     #[deriving(Hash, Eq, TotalEq)]
     struct Dropable {
-        k: uint
+        k: int
     }
 
 
     impl Dropable {
-        fn new(k: uint) -> Dropable {
+        fn new(k: int) -> Dropable {
             local_data::get_mut(drop_vector,
                 |v| { v.unwrap().as_mut_slice()[k] += 1; });
 
@@ -1628,24 +1628,24 @@ mod test_map {
             let mut m = HashMap::new();
 
             local_data::get(drop_vector, |v| {
-                for i in range(0u, 200) {
+                for i in range(0, 200) {
                     assert_eq!(v.unwrap().as_slice()[i], 0);
                 }
             });
 
-            for i in range(0u, 100) {
+            for i in range(0, 100) {
                 let d1 = Dropable::new(i);
                 let d2 = Dropable::new(i+100);
                 m.insert(d1, d2);
             }
 
             local_data::get(drop_vector, |v| {
-                for i in range(0u, 200) {
+                for i in range(0, 200) {
                     assert_eq!(v.unwrap().as_slice()[i], 1);
                 }
             });
 
-            for i in range(0u, 50) {
+            for i in range(0, 50) {
                 let k = Dropable::new(i);
                 let v = m.pop(&k);
 
@@ -1658,20 +1658,20 @@ mod test_map {
             }
 
             local_data::get(drop_vector, |v| {
-                for i in range(0u, 50) {
+                for i in range(0, 50) {
                     assert_eq!(v.unwrap().as_slice()[i], 0);
                     assert_eq!(v.unwrap().as_slice()[i+100], 0);
                 }
 
-                for i in range(50u, 100) {
+                for i in range(50, 100) {
                     assert_eq!(v.unwrap().as_slice()[i], 1);
                     assert_eq!(v.unwrap().as_slice()[i+100], 1);
                 }
             });
         }
 
         local_data::get(drop_vector, |v| {
-            for i in range(0u, 200) {
+            for i in range(0, 200) {
                 assert_eq!(v.unwrap().as_slice()[i], 0);
             }
         });

trunk/src/libflate/lib.rs

@@ -112,7 +112,7 @@ mod tests {
         for _ in range(0, 20) {
             let mut input = ~[];
             for _ in range(0, 2000) {
-                input.push_all(r.choose(words.as_slice()).as_slice());
+                input.push_all(r.choose(words.as_slice()));
             }
             debug!("de/inflate of {} bytes of random word-sequences",
                    input.len());

trunk/src/libgreen/sched.rs

@@ -967,12 +967,7 @@ impl ClosureConverter for UnsafeTaskReceiver {
 // worry there.
 #[cfg(windows)]
 fn new_sched_rng() -> XorShiftRng {
-    match XorShiftRng::new() {
-        Ok(r) => r,
-        Err(e) => {
-            rtabort!("sched: failed to create seeded RNG: {}", e)
-        }
-    }
+    XorShiftRng::new()
 }
 #[cfg(unix)]
 fn new_sched_rng() -> XorShiftRng {

trunk/src/libnative/io/addrinfo.rs

@@ -96,8 +96,10 @@ extern "system" {
 
 #[cfg(windows)]
 fn get_error(_: c_int) -> IoError {
+    use super::translate_error;
+
     unsafe {
-        IoError::from_errno(WSAGetLastError() as uint, true)
+        translate_error(WSAGetLastError() as i32, true)
     }
 }
 

trunk/src/libnative/io/mod.rs

@@ -86,10 +86,73 @@ fn unimpl() -> IoError {
     }
 }
 
-fn last_error() -> IoError {
-    IoError::last_error()
+fn translate_error(errno: i32, detail: bool) -> IoError {
+    #[cfg(windows)]
+    fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
+        match errno {
+            libc::EOF => (io::EndOfFile, "end of file"),
+            libc::ERROR_NO_DATA => (io::BrokenPipe, "the pipe is being closed"),
+            libc::ERROR_FILE_NOT_FOUND => (io::FileNotFound, "file not found"),
+            libc::ERROR_INVALID_NAME => (io::InvalidInput, "invalid file name"),
+            libc::WSAECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::WSAECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::WSAEACCES => (io::PermissionDenied, "permission denied"),
+            libc::WSAEWOULDBLOCK => {
+                (io::ResourceUnavailable, "resource temporarily unavailable")
+            }
+            libc::WSAENOTCONN => (io::NotConnected, "not connected"),
+            libc::WSAECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::WSAEADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::WSAEADDRINUSE => (io::ConnectionRefused, "address in use"),
+            libc::ERROR_BROKEN_PIPE => (io::EndOfFile, "the pipe has ended"),
+
+            // libuv maps this error code to EISDIR. we do too. if it is found
+            // to be incorrect, we can add in some more machinery to only
+            // return this message when ERROR_INVALID_FUNCTION after certain
+            // win32 calls.
+            libc::ERROR_INVALID_FUNCTION => (io::InvalidInput,
+                                             "illegal operation on a directory"),
+
+            _ => (io::OtherIoError, "unknown error")
+        }
+    }
+
+    #[cfg(not(windows))]
+    fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
+        // FIXME: this should probably be a bit more descriptive...
+        match errno {
+            libc::EOF => (io::EndOfFile, "end of file"),
+            libc::ECONNREFUSED => (io::ConnectionRefused, "connection refused"),
+            libc::ECONNRESET => (io::ConnectionReset, "connection reset"),
+            libc::EPERM | libc::EACCES =>
+                (io::PermissionDenied, "permission denied"),
+            libc::EPIPE => (io::BrokenPipe, "broken pipe"),
+            libc::ENOTCONN => (io::NotConnected, "not connected"),
+            libc::ECONNABORTED => (io::ConnectionAborted, "connection aborted"),
+            libc::EADDRNOTAVAIL => (io::ConnectionRefused, "address not available"),
+            libc::EADDRINUSE => (io::ConnectionRefused, "address in use"),
+            libc::ENOENT => (io::FileNotFound, "no such file or directory"),
+            libc::EISDIR => (io::InvalidInput, "illegal operation on a directory"),
+
+            // These two constants can have the same value on some systems, but
+            // different values on others, so we can't use a match clause
+            x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
+                (io::ResourceUnavailable, "resource temporarily unavailable"),
+
+            _ => (io::OtherIoError, "unknown error")
+        }
+    }
+
+    let (kind, desc) = get_err(errno);
+    IoError {
+        kind: kind,
+        desc: desc,
+        detail: if detail {Some(os::last_os_error())} else {None},
+    }
 }
 
+fn last_error() -> IoError { translate_error(os::errno() as i32, true) }
+
 // unix has nonzero values as errors
 fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
     if ret != 0 {

trunk/src/libnative/io/net.rs

@@ -120,7 +120,7 @@ fn last_error() -> io::IoError {
     extern "system" {
         fn WSAGetLastError() -> libc::c_int;
     }
-    io::IoError::from_errno(unsafe { WSAGetLastError() } as uint, true)
+    super::translate_error(unsafe { WSAGetLastError() }, true)
 }
 
 #[cfg(not(windows))]

trunk/src/libnative/io/process.rs

@@ -481,7 +481,7 @@ fn spawn_process_os(config: p::ProcessConfig,
                                     (bytes[1] << 16) as i32 |
                                     (bytes[2] <<  8) as i32 |
                                     (bytes[3] <<  0) as i32;
-                        Err(io::IoError::from_errno(errno as uint, false))
+                        Err(super::translate_error(errno, false))
                     }
                     Err(e) => {
                         assert!(e.kind == io::BrokenPipe ||