Test fixes and rebase conflicts

* vec::raw::to_ptr is gone
* Pausible => Pausable
* Removing @
* Calling the main task "<main>"
* Removing unused imports
* Removing unused mut
* Bringing some libextra tests up to date
* Allowing compiletest to work at stage0
* Fixing the bootstrap-from-c rmake tests
* assert => rtassert in a few cases
* printing to stderr instead of stdout in fail!()

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -13,6 +13,7 @@
 #[allow(non_camel_case_types)];
 #[deny(warnings)];
 
+#[cfg(stage0)] extern mod green;
 extern mod extra;
 
 use std::os;

src/libextra/comm.rs

@@ -96,7 +96,6 @@ pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
 #[cfg(test)]
 mod test {
     use comm::{DuplexStream, rendezvous};
-    use std::rt::test::run_in_uv_task;
 
 
     #[test]
@@ -124,13 +123,11 @@ mod test {
     #[test]
     fn recv_a_lot() {
         // Rendezvous streams should be able to handle any number of messages being sent
-        do run_in_uv_task {
-            let (port, chan) = rendezvous();
-            do spawn {
-                1000000.times(|| { chan.send(()) })
-            }
-            1000000.times(|| { port.recv() })
+        let (port, chan) = rendezvous();
+        do spawn {
+            1000000.times(|| { chan.send(()) })
         }
+        1000000.times(|| { port.recv() })
     }
 
     #[test]

src/libextra/sync.rs

@@ -761,23 +761,21 @@ mod tests {
     fn test_sem_runtime_friendly_blocking() {
         // Force the runtime to schedule two threads on the same sched_loop.
         // When one blocks, it should schedule the other one.
-        do task::spawn_sched(task::SingleThreaded) {
-            let s = Semaphore::new(1);
-            let s2 = s.clone();
-            let (p, c) = Chan::new();
-            let mut child_data = Some((s2, c));
-            s.access(|| {
-                let (s2, c) = child_data.take_unwrap();
-                do task::spawn {
-                    c.send(());
-                    s2.access(|| { });
-                    c.send(());
-                }
-                let _ = p.recv(); // wait for child to come alive
-                5.times(|| { task::deschedule(); }); // let the child contend
-            });
-            let _ = p.recv(); // wait for child to be done
-        }
+        let s = Semaphore::new(1);
+        let s2 = s.clone();
+        let (p, c) = Chan::new();
+        let mut child_data = Some((s2, c));
+        s.access(|| {
+            let (s2, c) = child_data.take_unwrap();
+            do task::spawn {
+                c.send(());
+                s2.access(|| { });
+                c.send(());
+            }
+            let _ = p.recv(); // wait for child to come alive
+            5.times(|| { task::deschedule(); }); // let the child contend
+        });
+        let _ = p.recv(); // wait for child to be done
     }
     /************************************************************************
      * Mutex tests

src/libextra/task_pool.rs

@@ -17,8 +17,6 @@
 use std::task;
 use std::vec;
 
-#[cfg(test)] use std::task::SingleThreaded;
-
 enum Msg<T> {
     Execute(proc(&T)),
     Quit

src/libgreen/basic.rs

@@ -16,7 +16,7 @@
 //! loop if no other one is provided (and M:N scheduling is desired).
 
 use std::cast;
-use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausibleIdleCallback,
+use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausableIdleCallback,
                     Callback};
 use std::unstable::sync::Exclusive;
 use std::util;

src/libgreen/lib.rs

@@ -18,12 +18,7 @@
 //! functionality inside of 1:1 programs.
 
 #[pkgid = "green#0.9-pre"];
-#[link(name = "green",
-       package_id = "green",
-       vers = "0.9-pre",
-       uuid = "20c38f8c-bfea-83ed-a068-9dc05277be26",
-       url = "https://github.com/mozilla/rust/tree/master/src/libgreen")];
-
+#[crate_id = "green#0.9-pre"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
@@ -61,16 +56,13 @@ pub mod stack;
 pub mod task;
 
 #[lang = "start"]
+#[cfg(not(test))]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
     use std::cast;
-    let mut ret = None;
-    simple::task().run(|| {
-        ret = Some(do start(argc, argv) {
-            let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
-            main();
-        })
-    });
-    ret.unwrap()
+    do start(argc, argv) {
+        let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
+        main();
+    }
 }
 
 /// Set up a default runtime configuration, given compiler-supplied arguments.
@@ -93,10 +85,14 @@ pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
 /// error.
 pub fn start(argc: int, argv: **u8, main: proc()) -> int {
     rt::init(argc, argv);
-    let exit_code = run(main);
+    let mut main = Some(main);
+    let mut ret = None;
+    simple::task().run(|| {
+        ret = Some(run(main.take_unwrap()));
+    });
     // unsafe is ok b/c we're sure that the runtime is gone
     unsafe { rt::cleanup() }
-    exit_code
+    ret.unwrap()
 }
 
 /// Execute the main function in a pool of M:N schedulers.
@@ -114,6 +110,7 @@ pub fn run(main: proc()) -> int {
     let (port, chan) = Chan::new();
     let mut opts = TaskOpts::new();
     opts.notify_chan = Some(chan);
+    opts.name = Some(SendStrStatic("<main>"));
     pool.spawn(opts, main);
 
     // Wait for the main task to return, and set the process error code

src/libgreen/macros.rs

@@ -54,14 +54,13 @@ macro_rules! rtabort (
 pub fn dumb_println(args: &fmt::Arguments) {
     use std::io;
     use std::libc;
-    use std::vec;
 
     struct Stderr;
     impl io::Writer for Stderr {
         fn write(&mut self, data: &[u8]) {
             unsafe {
                 libc::write(libc::STDERR_FILENO,
-                            vec::raw::to_ptr(data) as *libc::c_void,
+                            data.as_ptr() as *libc::c_void,
                             data.len() as libc::size_t);
             }
         }

src/libgreen/sched.rs

@@ -11,7 +11,7 @@
 use std::cast;
 use std::rand::{XorShiftRng, Rng, Rand};
 use std::rt::local::Local;
-use std::rt::rtio::{RemoteCallback, PausibleIdleCallback, Callback, EventLoop};
+use std::rt::rtio::{RemoteCallback, PausableIdleCallback, Callback, EventLoop};
 use std::rt::task::BlockedTask;
 use std::rt::task::Task;
 use std::sync::deque;
@@ -779,6 +779,9 @@ impl Scheduler {
     /// randomness is a result of performing a round of work stealing (which
     /// may end up stealing from the current scheduler).
     pub fn yield_now(mut ~self, cur: ~GreenTask) {
+        // Async handles trigger the scheduler by calling yield_now on the local
+        // task, which eventually gets us to here. See comments in SchedRunner
+        // for more info on this.
         if cur.is_sched() {
             assert!(self.sched_task.is_none());
             self.run_sched_once(cur);
@@ -1345,7 +1348,7 @@ mod test {
 
             impl Drop for S {
                 fn drop(&mut self) {
-                    let _foo = @0;
+                    let _foo = ~0;
                 }
             }
 

src/libnative/io/process.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::cast;
 use std::io;
 use std::libc::{pid_t, c_void, c_int};
 use std::libc;
@@ -17,6 +16,8 @@ use std::ptr;
 use std::rt::rtio;
 use p = std::io::process;
 
+#[cfg(windows)] use std::cast;
+
 use super::file;
 
 /**

src/libnative/lib.rs

@@ -15,12 +15,7 @@
 //! version of I/O.
 
 #[pkgid = "native#0.9-pre"];
-#[link(name = "native",
-       package_id = "native",
-       vers = "0.9-pre",
-       uuid = "535344a7-890f-5a23-e1f3-e0d118805141",
-       url = "https://github.com/mozilla/rust/tree/master/src/native")];
-
+#[crate_id = "native#0.9-pre"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
@@ -46,7 +41,7 @@ pub mod task;
 #[lang = "start"]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
     use std::cast;
-    use std::task::try;
+    use std::task;
 
     do start(argc, argv) {
         // Instead of invoking main directly on this thread, invoke it on
@@ -55,7 +50,9 @@ pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
         // of the main thread's stack, so for stack overflow detection to work
         // we must spawn the task in a subtask which we know the stack size of.
         let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
-        match do try { main() } {
+        let mut task = task::task();
+        task.name("<main>");
+        match do task.try { main() } {
             Ok(()) => { os::set_exit_status(0); }
             Err(..) => { os::set_exit_status(rt::DEFAULT_ERROR_CODE); }
         }