---

yaml
---
r: 64597
b: refs/heads/snap-stage3
c: 9ed82fb
h: refs/heads/master
i:
  64595: 1e6fe01
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 73ab6c60f37263871a5e69f3eeaad72f0d804a02
+refs/heads/snap-stage3: 9ed82fbb43804ebc7e06daca5812079630ec8952
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -242,13 +242,13 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
     let mut tests = ~[];
     let dirs = os::list_dir_path(&config.src_base);
     for dirs.iter().advance |file| {
-        let file = (*file).clone();
+        let file = file.clone();
         debug!("inspecting file %s", file.to_str());
-        if is_test(config, file) {
-            let t = do make_test(config, file) {
+        if is_test(config, &file) {
+            let t = do make_test(config, &file) {
                 match config.mode {
-                    mode_codegen => make_metrics_test_closure(config, file),
-                    _ => make_test_closure(config, file)
+                    mode_codegen => make_metrics_test_closure(config, &file),
+                    _ => make_test_closure(config, &file)
                 }
             };
             tests.push(t)

branches/snap-stage3/src/librustc/metadata/filesearch.rs

@@ -94,7 +94,7 @@ pub fn search<T>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
         let r = os::list_dir_path(lib_search_path);
         for r.iter().advance |path| {
             debug!("testing %s", path.to_str());
-            let maybe_picked = pick(*path);
+            let maybe_picked = pick(path);
             if maybe_picked.is_some() {
                 debug!("picked %s", path.to_str());
                 rslt = maybe_picked;

branches/snap-stage3/src/librustpkg/tests.rs

@@ -393,9 +393,9 @@ fn frob_source_file(workspace: &Path, pkgid: &PkgId) {
     }
     match maybe_p {
         Some(p) => {
-            let w = io::file_writer(*p, &[io::Append]);
+            let w = io::file_writer(p, &[io::Append]);
             match w {
-                Err(s) => { let _ = cond.raise(((**p).clone(), fmt!("Bad path: %s", s))); }
+                Err(s) => { let _ = cond.raise((p.clone(), fmt!("Bad path: %s", s))); }
                 Ok(w)  => w.write_line("")
             }
         }

branches/snap-stage3/src/libstd/os.rs

@@ -788,8 +788,8 @@ pub fn list_dir(p: &Path) -> ~[~str] {
  *
  * This version prepends each entry with the directory.
  */
-pub fn list_dir_path(p: &Path) -> ~[~Path] {
-    list_dir(p).map(|f| ~p.push(*f))
+pub fn list_dir_path(p: &Path) -> ~[Path] {
+    list_dir(p).map(|f| p.push(*f))
 }
 
 /// Removes a directory at the specified path, after removing

branches/snap-stage3/src/libstd/rt/io/mod.rs

@@ -252,7 +252,6 @@ pub use self::stdio::print;
 pub use self::stdio::println;
 
 pub use self::file::FileStream;
-pub use self::timer::Timer;
 pub use self::net::ip::IpAddr;
 pub use self::net::tcp::TcpListener;
 pub use self::net::tcp::TcpStream;
@@ -297,9 +296,6 @@ mod extensions;
 /// Non-I/O things needed by the I/O module
 mod support;
 
-/// Basic Timer
-pub mod timer;
-
 /// Thread-blocking implementations
 pub mod native {
     /// Posix file I/O

branches/snap-stage3/src/libstd/rt/io/timer.rs

@@ -23,7 +23,6 @@ pub type IoFactoryObject = uvio::UvIoFactory;
 pub type RtioTcpStreamObject = uvio::UvTcpStream;
 pub type RtioTcpListenerObject = uvio::UvTcpListener;
 pub type RtioUdpSocketObject = uvio::UvUdpSocket;
-pub type RtioTimerObject = uvio::UvTimer;
 
 pub trait EventLoop {
     fn run(&mut self);
@@ -47,7 +46,6 @@ pub trait IoFactory {
     fn tcp_connect(&mut self, addr: IpAddr) -> Result<~RtioTcpStreamObject, IoError>;
     fn tcp_bind(&mut self, addr: IpAddr) -> Result<~RtioTcpListenerObject, IoError>;
     fn udp_bind(&mut self, addr: IpAddr) -> Result<~RtioUdpSocketObject, IoError>;
-    fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError>;
 }
 
 pub trait RtioTcpListener : RtioSocket {
@@ -86,7 +84,3 @@ pub trait RtioUdpSocket : RtioSocket {
     fn hear_broadcasts(&mut self);
     fn ignore_broadcasts(&mut self);
 }
-
-pub trait RtioTimer {
-    fn sleep(&self, msecs: u64);
-}

branches/snap-stage3/src/libstd/rt/rtio.rs

@@ -280,10 +280,6 @@ impl IoFactory for UvIoFactory {
             }
         }
     }
-
-    fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError> {
-        Ok(~UvTimer(TimerWatcher::new(self.uv_loop())))
-    }
 }
 
 // FIXME #6090: Prefer newtype structs but Drop doesn't work
@@ -566,48 +562,6 @@ impl RtioUdpSocket for UvUdpSocket {
     fn ignore_broadcasts(&mut self) { fail!(); }
 }
 
-pub struct UvTimer(timer::TimerWatcher);
-
-impl UvTimer {
-    fn new(w: timer::TimerWatcher) -> UvTimer {
-        UvTimer(w)
-    }
-}
-
-impl Drop for UvTimer {
-    fn drop(&self) {
-        rtdebug!("closing UvTimer");
-        let scheduler = Local::take::<Scheduler>();
-        do scheduler.deschedule_running_task_and_then |_, task| {
-            let task_cell = Cell::new(task);
-            do self.close {
-                let scheduler = Local::take::<Scheduler>();
-                scheduler.resume_task_immediately(task_cell.take());
-            }
-        }
-    }
-}
-
-impl RtioTimer for UvTimer {
-    fn sleep(&self, msecs: u64) {
-        let scheduler = Local::take::<Scheduler>();
-        assert!(scheduler.in_task_context());
-        do scheduler.deschedule_running_task_and_then |sched, task| {
-            rtdebug!("sleep: entered scheduler context");
-            assert!(!sched.in_task_context());
-            let task_cell = Cell::new(task);
-            let mut watcher = **self;
-            do watcher.start(msecs, 0) |_, status| {
-                assert!(status.is_none());
-                let scheduler = Local::take::<Scheduler>();
-                scheduler.resume_task_immediately(task_cell.take());
-            }
-        }
-        let mut w = **self;
-        w.stop();
-    }
-}
-
 #[test]
 fn test_simple_io_no_connect() {
     do run_in_newsched_task {
@@ -878,20 +832,3 @@ fn test_udp_many_read() {
         }
     }
 }
-
-fn test_timer_sleep_simple_impl() {
-    unsafe {
-        let io = Local::unsafe_borrow::<IoFactoryObject>();
-        let timer = (*io).timer_init();
-        match timer {
-            Ok(t) => t.sleep(1),
-            Err(_) => assert!(false)
-        }
-    }
-}
-#[test]
-fn test_timer_sleep_simple() {
-    do run_in_newsched_task {
-        test_timer_sleep_simple_impl();
-    }
-}

branches/snap-stage3/src/libstd/rt/uv/uvio.rs

@@ -689,6 +689,8 @@ impl<'self,T:Clone> CopyableVector<T> for &'self [T] {
 #[allow(missing_doc)]
 pub trait ImmutableVector<'self, T> {
     fn slice(&self, start: uint, end: uint) -> &'self [T];
+    fn slice_from(&self, start: uint) -> &'self [T];
+    fn slice_to(&self, end: uint) -> &'self [T];
     fn iter(self) -> VecIterator<'self, T>;
     fn rev_iter(self) -> VecRevIterator<'self, T>;
     fn split_iter(self, pred: &'self fn(&T) -> bool) -> VecSplitIterator<'self, T>;
@@ -720,11 +722,17 @@ pub trait ImmutableVector<'self, T> {
 
 /// Extension methods for vectors
 impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
-    /// Return a slice that points into another slice.
+
+    /**
+     * Returns a slice of self between `start` and `end`.
+     *
+     * Fails when `start` or `end` point outside the bounds of self,
+     * or when `start` > `end`.
+     */
     #[inline]
     fn slice(&self, start: uint, end: uint) -> &'self [T] {
-    assert!(start <= end);
-    assert!(end <= self.len());
+        assert!(start <= end);
+        assert!(end <= self.len());
         do self.as_imm_buf |p, _len| {
             unsafe {
                 transmute((ptr::offset(p, start),
@@ -733,6 +741,26 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
         }
     }
 
+    /**
+     * Returns a slice of self from `start` to the end of the vec.
+     *
+     * Fails when `start` points outside the bounds of self.
+     */
+    #[inline]
+    fn slice_from(&self, start: uint) -> &'self [T] {
+        self.slice(start, self.len())
+    }
+
+    /**
+     * Returns a slice of self from the start of the vec to `end`.
+     *
+     * Fails when `end` points outside the bounds of self.
+     */
+    #[inline]
+    fn slice_to(&self, end: uint) -> &'self [T] {
+        self.slice(0, end)
+    }
+
     #[inline]
     fn iter(self) -> VecIterator<'self, T> {
         unsafe {
@@ -2453,6 +2481,22 @@ mod tests {
         assert_eq!(v_d[4], 6);
     }
 
+    #[test]
+    fn test_slice_from() {
+        let vec = &[1, 2, 3, 4];
+        assert_eq!(vec.slice_from(0), vec);
+        assert_eq!(vec.slice_from(2), &[3, 4]);
+        assert_eq!(vec.slice_from(4), &[]);
+    }
+
+    #[test]
+    fn test_slice_to() {
+        let vec = &[1, 2, 3, 4];
+        assert_eq!(vec.slice_to(4), vec);
+        assert_eq!(vec.slice_to(2), &[1, 2]);
+        assert_eq!(vec.slice_to(0), &[]);
+    }
+
     #[test]
     fn test_pop() {
         // Test on-heap pop.