---

yaml
---
r: 154318
b: refs/heads/try2
c: c3ce245
h: refs/heads/master
v: v3

Author: pnkfelix

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

branches/try2/src/compiletest/runtest.rs

@@ -30,7 +30,6 @@ use std::os;
 use std::str;
 use std::string::String;
 use std::task;
-use std::time::Duration;
 use test::MetricMap;
 
 pub fn run(config: Config, testfile: String) {
@@ -401,7 +400,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
             loop {
                 //waiting 1 second for gdbserver start
-                timer::sleep(Duration::milliseconds(1000));
+                timer::sleep(1000);
                 let result = task::try(proc() {
                     tcp::TcpStream::connect("127.0.0.1", 5039).unwrap();
                 });

branches/try2/src/doc/guide-runtime.md

@@ -128,7 +128,7 @@ itself, yet again implying that they are not defined in the standard library.
 The full complement of runtime features is defined by the [`Runtime`
 trait](std/rt/trait.Runtime.html) and the [`Task`
 struct](std/rt/task/struct.Task.html). A `Task` is constant among all runtime
-implementations, but each runtime has its own implementation of the
+implementations, but each runtime implements has its own implementation of the
 `Runtime` trait.
 
 The local `Task` stores the runtime value inside of itself, and then ownership

branches/try2/src/doc/guide-testing.md

@@ -198,7 +198,7 @@ per-iteration speed of.
 
 For benchmarks relating to processing/generating data, one can set the
 `bytes` field to the number of bytes consumed/produced in each
-iteration; this will be used to show the throughput of the benchmark.
+iteration; this will used to show the throughput of the benchmark.
 This must be the amount used in each iteration, *not* the total
 amount.
 

branches/try2/src/doc/guide-unsafe.md

@@ -137,7 +137,7 @@ explicitly with, respectively, `value as *const T` and `value as *mut T`).
 
 Going the opposite direction, from `*const` to a reference `&`, is not
 safe. A `&T` is always valid, and so, at a minimum, the raw pointer
-`*const T` has to point to a valid instance of type `T`. Furthermore,
+`*const T` has to be a valid to a valid instance of type `T`. Furthermore,
 the resulting pointer must satisfy the aliasing and mutability laws of
 references. The compiler assumes these properties are true for any
 references, no matter how they are created, and so any conversion from

branches/try2/src/doc/guide.md

@@ -666,7 +666,7 @@ This is not the same as this, which won't compile:
 ```{ignore}
 let x = 5i;
 
-let y: int = if x == 5i { 10i; } else { 15i; };
+let y: int = if x == 5 { 10i; } else { 15i; };
 ```
 
 Note the semicolons after the 10 and 15. Rust will give us the following error:

branches/try2/src/doc/rust.md

@@ -1356,9 +1356,6 @@ A *static item* is a named _constant value_ stored in the global data section of
 Immutable static items are stored in the read-only data section.
 The constant value bound to a static item is, like all constant values, evaluated at compile time.
 Static items have the `static` lifetime, which outlives all other lifetimes in a Rust program.
-Only values stored in the global data section (such as string constants
-and static items) can have the `static` lifetime;
-dynamically constructed values cannot safely be assigned the `static` lifetime.
 Static items are declared with the `static` keyword.
 A static item must have a _constant expression_ giving its definition.
 
@@ -3624,10 +3621,7 @@ There are four varieties of pointer in Rust:
     References arise by (automatic) conversion from owning pointers, managed pointers,
     or by applying the borrowing operator `&` to some other value,
     including [lvalues, rvalues or temporaries](#lvalues,-rvalues-and-temporaries).
-    A borrow expression is written `&content`.
-
-    A reference type is written `&'f type` for some lifetime-variable `f`,
-    or just `&type` when the lifetime can be elided;
+    References are written `&content`, or in some cases `&'f content` for some lifetime-variable `f`,
     for example `&int` means a reference to an integer.
     Copying a reference is a "shallow" operation:
     it involves only copying the pointer itself.

branches/try2/src/libgreen/sched.rs

@@ -1029,7 +1029,6 @@ mod test {
     use std::rt::task::TaskOpts;
     use std::rt::task::Task;
     use std::rt::local::Local;
-    use std::time::Duration;
 
     use {TaskState, PoolConfig, SchedPool};
     use basic;
@@ -1292,7 +1291,7 @@ mod test {
         // doesn't exit before emptying the work queue
         pool.spawn(TaskOpts::new(), proc() {
             spawn(proc() {
-                timer::sleep(Duration::milliseconds(10));
+                timer::sleep(10);
             });
         });
 

branches/try2/src/libstd/io/net/tcp.rs

@@ -27,15 +27,13 @@ use io::net::addrinfo::get_host_addresses;
 use io::net::ip::SocketAddr;
 use io::{IoError, ConnectionFailed, InvalidInput};
 use io::{Reader, Writer, Listener, Acceptor};
-use io::{standard_error, TimedOut};
 use from_str::FromStr;
 use kinds::Send;
 use option::{None, Some, Option};
 use boxed::Box;
 use rt::rtio::{IoFactory, LocalIo, RtioSocket, RtioTcpListener};
 use rt::rtio::{RtioTcpAcceptor, RtioTcpStream};
 use rt::rtio;
-use time::Duration;
 
 /// A structure which represents a TCP stream between a local socket and a
 /// remote socket.
@@ -94,28 +92,21 @@ impl TcpStream {
     }
 
     /// Creates a TCP connection to a remote socket address, timing out after
-    /// the specified duration.
+    /// the specified number of milliseconds.
     ///
     /// This is the same as the `connect` method, except that if the timeout
     /// specified (in milliseconds) elapses before a connection is made an error
     /// will be returned. The error's kind will be `TimedOut`.
     ///
     /// Note that the `addr` argument may one day be split into a separate host
     /// and port, similar to the API seen in `connect`.
-    ///
-    /// If a `timeout` with zero or negative duration is specified then
-    /// the function returns `Err`, with the error kind set to `TimedOut`.
     #[experimental = "the timeout argument may eventually change types"]
     pub fn connect_timeout(addr: SocketAddr,
-                           timeout: Duration) -> IoResult<TcpStream> {
-        if timeout <= Duration::milliseconds(0) {
-            return Err(standard_error(TimedOut));
-        }
-
+                           timeout_ms: u64) -> IoResult<TcpStream> {
         let SocketAddr { ip, port } = addr;
         let addr = rtio::SocketAddr { ip: super::to_rtio(ip), port: port };
         LocalIo::maybe_raise(|io| {
-            io.tcp_connect(addr, Some(timeout.num_milliseconds() as u64)).map(TcpStream::new)
+            io.tcp_connect(addr, Some(timeout_ms)).map(TcpStream::new)
         }).map_err(IoError::from_rtio_error)
     }
 
@@ -173,14 +164,13 @@ impl TcpStream {
     /// # #![allow(unused_must_use)]
     /// use std::io::timer;
     /// use std::io::TcpStream;
-    /// use std::time::Duration;
     ///
     /// let mut stream = TcpStream::connect("127.0.0.1", 34254).unwrap();
     /// let stream2 = stream.clone();
     ///
     /// spawn(proc() {
     ///     // close this stream after one second
-    ///     timer::sleep(Duration::seconds(1));
+    ///     timer::sleep(1000);
     ///     let mut stream = stream2;
     ///     stream.close_read();
     /// });

branches/try2/src/libstd/io/net/unix.rs

@@ -29,12 +29,10 @@ use prelude::*;
 use c_str::ToCStr;
 use clone::Clone;
 use io::{Listener, Acceptor, Reader, Writer, IoResult, IoError};
-use io::{standard_error, TimedOut};
 use kinds::Send;
 use boxed::Box;
 use rt::rtio::{IoFactory, LocalIo, RtioUnixListener};
 use rt::rtio::{RtioUnixAcceptor, RtioPipe};
-use time::Duration;
 
 /// A stream which communicates over a named pipe.
 pub struct UnixStream {
@@ -68,18 +66,11 @@ impl UnixStream {
     ///
     /// This function is similar to `connect`, except that if `timeout_ms`
     /// elapses the function will return an error of kind `TimedOut`.
-    ///
-    /// If a `timeout` with zero or negative duration is specified then
-    /// the function returns `Err`, with the error kind set to `TimedOut`.
     #[experimental = "the timeout argument is likely to change types"]
     pub fn connect_timeout<P: ToCStr>(path: &P,
-                                      timeout: Duration) -> IoResult<UnixStream> {
-        if timeout <= Duration::milliseconds(0) {
-            return Err(standard_error(TimedOut));
-        }
-
+                                      timeout_ms: u64) -> IoResult<UnixStream> {
         LocalIo::maybe_raise(|io| {
-            let s = io.unix_connect(&path.to_c_str(), Some(timeout.num_milliseconds() as u64));
+            let s = io.unix_connect(&path.to_c_str(), Some(timeout_ms));
             s.map(|p| UnixStream { obj: p })
         }).map_err(IoError::from_rtio_error)
     }
@@ -508,25 +499,13 @@ mod tests {
 
     iotest!(fn connect_timeout_error() {
         let addr = next_test_unix();
-        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(100)).is_err());
+        assert!(UnixStream::connect_timeout(&addr, 100).is_err());
     })
 
     iotest!(fn connect_timeout_success() {
         let addr = next_test_unix();
         let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
-        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(100)).is_ok());
-    })
-
-    iotest!(fn connect_timeout_zero() {
-        let addr = next_test_unix();
-        let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
-        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(0)).is_err());
-    })
-
-    iotest!(fn connect_timeout_negative() {
-        let addr = next_test_unix();
-        let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
-        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(-1)).is_err());
+        assert!(UnixStream::connect_timeout(&addr, 100).is_ok());
     })
 
     iotest!(fn close_readwrite_smoke() {

branches/try2/src/libstd/io/process.rs

@@ -976,7 +976,7 @@ mod tests {
                 assert!(!p.wait().unwrap().success());
                 return
             }
-            timer::sleep(Duration::milliseconds(100));
+            timer::sleep(100);
         }
         fail!("never saw the child go away");
     })

branches/try2/src/libstd/io/signal.rs

@@ -167,7 +167,6 @@ mod test_unix {
     use comm::Empty;
     use io::timer;
     use super::{Listener, Interrupt};
-    use time::Duration;
 
     fn sigint() {
         unsafe {
@@ -180,7 +179,7 @@ mod test_unix {
         let mut signal = Listener::new();
         signal.register(Interrupt).unwrap();
         sigint();
-        timer::sleep(Duration::milliseconds(10));
+        timer::sleep(10);
         match signal.rx.recv() {
             Interrupt => (),
             s => fail!("Expected Interrupt, got {:?}", s),
@@ -194,7 +193,7 @@ mod test_unix {
         s1.register(Interrupt).unwrap();
         s2.register(Interrupt).unwrap();
         sigint();
-        timer::sleep(Duration::milliseconds(10));
+        timer::sleep(10);
         match s1.rx.recv() {
             Interrupt => (),
             s => fail!("Expected Interrupt, got {:?}", s),
@@ -213,7 +212,7 @@ mod test_unix {
         s2.register(Interrupt).unwrap();
         s2.unregister(Interrupt);
         sigint();
-        timer::sleep(Duration::milliseconds(10));
+        timer::sleep(10);
         assert_eq!(s2.rx.try_recv(), Err(Empty));
     }
 }

branches/try2/src/libstd/io/test.rs

@@ -39,7 +39,6 @@ macro_rules! iotest (
             use io::process::*;
             use rt::running_on_valgrind;
             use str;
-            use time::Duration;
 
             fn f() $b