Remove all use of librustuv

src/compiletest/compiletest.rs

@@ -11,15 +11,10 @@
 #![crate_type = "bin"]
 #![feature(phase)]
 
-// we use our own (green) start below; do not link in libnative; issue #13247.
-#![no_start]
-
 #![deny(warnings)]
 
 extern crate test;
 extern crate getopts;
-extern crate green;
-extern crate rustuv;
 #[phase(plugin, link)] extern crate log;
 
 extern crate regex;
@@ -41,11 +36,6 @@ pub mod runtest;
 pub mod common;
 pub mod errors;
 
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 pub fn main() {
     let args = os::args();
     let config = parse_config(args);

src/doc/guide-runtime.md

@@ -240,7 +240,7 @@ To create a pool of green tasks which have no I/O support, you may shed the
 `rustuv::event_loop`. All tasks will have no I/O support, but they will still be
 able to deschedule/reschedule (use channels, locks, etc).
 
-~~~{.rust}
+~~~{.ignore}
 extern crate green;
 extern crate rustuv;
 

src/libgreen/lib.rs

@@ -128,35 +128,6 @@
 //! > **Note**: This `main` function in this example does *not* have I/O
 //! >           support. The basic event loop does not provide any support
 //!
-//! # Starting with I/O support in libgreen
-//!
-//! ```rust
-//! extern crate green;
-//! extern crate rustuv;
-//!
-//! #[start]
-//! fn start(argc: int, argv: *const *const u8) -> int {
-//!     green::start(argc, argv, rustuv::event_loop, main)
-//! }
-//!
-//! fn main() {
-//!     // this code is running in a pool of schedulers all powered by libuv
-//! }
-//! ```
-//!
-//! The above code can also be shortened with a macro from libgreen.
-//!
-//! ```
-//! #![feature(phase)]
-//! #[phase(plugin)] extern crate green;
-//!
-//! green_start!(main)
-//!
-//! fn main() {
-//!     // run inside of a green pool
-//! }
-//! ```
-//!
 //! # Using a scheduler pool
 //!
 //! This library adds a `GreenTaskBuilder` trait that extends the methods
@@ -165,7 +136,6 @@
 //!
 //! ```rust
 //! extern crate green;
-//! extern crate rustuv;
 //!
 //! # fn main() {
 //! use std::task::TaskBuilder;
@@ -173,9 +143,6 @@
 //!
 //! let mut config = PoolConfig::new();
 //!
-//! // Optional: Set the event loop to be rustuv's to allow I/O to work
-//! config.event_loop_factory = rustuv::event_loop;
-//!
 //! let mut pool = SchedPool::new(config);
 //!
 //! // Spawn tasks into the pool of schedulers
@@ -221,7 +188,6 @@
 #![allow(deprecated)]
 
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
-#[cfg(test)] extern crate rustuv;
 extern crate libc;
 extern crate alloc;
 
@@ -253,33 +219,6 @@ pub mod sleeper_list;
 pub mod stack;
 pub mod task;
 
-/// A helper macro for booting a program with libgreen
-///
-/// # Example
-///
-/// ```
-/// #![feature(phase)]
-/// #[phase(plugin)] extern crate green;
-///
-/// green_start!(main)
-///
-/// fn main() {
-///     // running with libgreen
-/// }
-/// ```
-#[macro_export]
-macro_rules! green_start( ($f:ident) => (
-    mod __start {
-        extern crate green;
-        extern crate rustuv;
-
-        #[start]
-        fn start(argc: int, argv: *const *const u8) -> int {
-            green::start(argc, argv, rustuv::event_loop, super::$f)
-        }
-    }
-) )
-
 /// Set up a default runtime configuration, given compiler-supplied arguments.
 ///
 /// This function will block until the entire pool of M:N schedulers have

src/libgreen/sched.rs

@@ -1024,8 +1024,6 @@ fn new_sched_rng() -> XorShiftRng {
 
 #[cfg(test)]
 mod test {
-    use rustuv;
-
     use std::rt::task::TaskOpts;
     use std::rt::task::Task;
     use std::rt::local::Local;
@@ -1277,28 +1275,6 @@ mod test {
     //    }
     //}
 
-    #[test]
-    fn test_io_callback() {
-        use std::io::timer;
-
-        let mut pool = SchedPool::new(PoolConfig {
-            threads: 2,
-            event_loop_factory: rustuv::event_loop,
-        });
-
-        // This is a regression test that when there are no schedulable tasks in
-        // the work queue, but we are performing I/O, that once we do put
-        // something in the work queue again the scheduler picks it up and
-        // doesn't exit before emptying the work queue
-        pool.spawn(TaskOpts::new(), proc() {
-            spawn(proc() {
-                timer::sleep(Duration::milliseconds(10));
-            });
-        });
-
-        pool.shutdown();
-    }
-
     #[test]
     fn wakeup_across_scheds() {
         let (tx1, rx1) = channel();

src/libgreen/task.rs

@@ -506,7 +506,7 @@ mod tests {
     fn spawn_opts(opts: TaskOpts, f: proc():Send) {
         let mut pool = SchedPool::new(PoolConfig {
             threads: 1,
-            event_loop_factory: ::rustuv::event_loop,
+            event_loop_factory: super::super::basic::event_loop,
         });
         pool.spawn(opts, f);
         pool.shutdown();

src/libstd/lib.rs

@@ -116,11 +116,6 @@
 
 #![reexport_test_harness_main = "test_main"]
 
-// When testing libstd, bring in libuv as the I/O backend so tests can print
-// things and all of the std::io tests have an I/O interface to run on top
-// of
-#[cfg(test)] extern crate rustuv;
-#[cfg(test)] extern crate native;
 #[cfg(test)] extern crate green;
 #[cfg(test)] extern crate debug;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
@@ -187,12 +182,6 @@ pub use unicode::char;
 
 pub use core_sync::comm;
 
-// Run tests with libgreen instead of libnative.
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
 /* Exported macros */
 
 pub mod macros;

src/test/bench/rt-spawn-rate.rs

@@ -11,7 +11,6 @@
 #![no_start]
 
 extern crate green;
-extern crate rustuv;
 
 use std::task::spawn;
 use std::os;
@@ -22,7 +21,7 @@ use std::uint;
 
 #[start]
 fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
+    green::start(argc, argv, green::basic::event_loop, main)
 }
 
 fn main() {

src/test/bench/shootout-chameneos-redux.rs

@@ -40,14 +40,9 @@
 
 // no-pretty-expanded
 
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-
 use std::string::String;
 use std::fmt;
 
-green_start!(main)
-
 fn print_complements() {
     let all = [Blue, Red, Yellow];
     for aa in all.iter() {

src/test/bench/shootout-meteor.rs

@@ -40,13 +40,8 @@
 
 // no-pretty-expanded FIXME #15189
 
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-
 use std::sync::Arc;
 
-green_start!(main)
-
 //
 // Utilities.
 //

src/test/bench/shootout-spectralnorm.rs

@@ -40,9 +40,7 @@
 
 // no-pretty-expanded FIXME #15189
 
-#![feature(phase)]
 #![allow(non_snake_case)]
-#[phase(plugin)] extern crate green;
 
 use std::from_str::FromStr;
 use std::iter::count;
@@ -50,8 +48,6 @@ use std::cmp::min;
 use std::os;
 use std::sync::{Arc, RWLock};
 
-green_start!(main)
-
 fn A(i: uint, j: uint) -> f64 {
     ((i + j) * (i + j + 1) / 2 + i + 1) as f64
 }

src/test/bench/shootout-threadring.rs

@@ -38,10 +38,6 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-green_start!(main)
-
 fn start(n_tasks: int, token: int) {
     let (tx, mut rx) = channel();
     tx.send(token);

src/test/bench/silly-test-spawn.rs

@@ -9,16 +9,13 @@
 // except according to those terms.
 
 // This is (hopefully) a quick test to get a good idea about spawning
-// performance in libgreen. Note that this uses the rustuv event loop rather
+// performance in libgreen.
-// than the basic event loop in order to get a better real world idea about the
-// performance of a task spawn.
 
 extern crate green;
-extern crate rustuv;
 
 #[start]
 fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
+    green::start(argc, argv, green::basic::event_loop, main)
 }
 
 fn main() {

src/test/run-make/bootstrap-from-c-with-green/Makefile

@@ -1,12 +0,0 @@
--include ../tools.mk
-
-HOST_LIB_DIR=$(TMPDIR)/../../../stage$(RUST_BUILD_STAGE)/lib
-# This overrides the LD_LIBRARY_PATH for RUN
-TARGET_RPATH_DIR:=$(TARGET_RPATH_DIR):$(TMPDIR)
-
-all:
-	$(RUSTC) lib.rs
-	$(CC) main.c -o $(call RUN_BINFILE,main) $(call RPATH_LINK_SEARCH,$(HOST_LIB_DIR)) -lboot
-	$(call RUN,main)
-	$(call REMOVE_DYLIBS,boot)
-	$(call FAIL,main)

src/test/run-make/bootstrap-from-c-with-green/lib.rs

@@ -1,24 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![crate_name="boot"]
-#![crate_type="dylib"]
-
-extern crate rustuv;
-extern crate green;
-
-#[no_mangle] // this needs to get called from C
-pub extern "C" fn foo(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, proc() {
-        spawn(proc() {
-            println!("hello");
-        });
-    })
-}

src/test/run-make/bootstrap-from-c-with-green/main.c

@@ -1,16 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// this is the rust entry point that we're going to call.
-int foo(int argc, char *argv[]);
-
-int main(int argc, char *argv[]) {
-  return foo(argc, argv);
-}

src/test/run-pass/core-run-destroy.rs

@@ -21,53 +21,24 @@
 extern crate libc;
 
 extern crate native;
-extern crate green;
-extern crate rustuv;
 
-use std::io::{Process, Command};
+use std::io::{Process, Command, timer};
 use std::time::Duration;
 
+use libc;
+use std::str;
+
 macro_rules! succeed( ($e:expr) => (
     match $e { Ok(..) => {}, Err(e) => fail!("failure: {}", e) }
 ) )
 
-macro_rules! iotest (
+fn test_destroy_once() {
-    { fn $name:ident() $b:block $($a:attr)* } => (
-        mod $name {
-            #![allow(unused_imports)]
-
-            use std::io::timer;
-            use libc;
-            use std::str;
-            use std::io::process::Command;
-            use native;
-            use super::{sleeper, test_destroy_actually_kills};
-
-            fn f() $b
-
-            $($a)* #[test] fn green() { f() }
-            $($a)* #[test] fn native() {
-                use native;
-                let (tx, rx) = channel();
-                native::task::spawn(proc() { tx.send(f()) });
-                rx.recv();
-            }
-        }
-    )
-)
-
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
-iotest!(fn test_destroy_once() {
     let mut p = sleeper();
     match p.signal_exit() {
         Ok(()) => {}
         Err(e) => fail!("error: {}", e),
     }
-})
+}
 
 #[cfg(unix)]
 pub fn sleeper() -> Process {
@@ -81,11 +52,11 @@ pub fn sleeper() -> Process {
     Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap()
 }
 
-iotest!(fn test_destroy_twice() {
+fn test_destroy_twice() {
     let mut p = sleeper();
     succeed!(p.signal_exit()); // this shouldnt crash...
     let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
-})
+}
 
 pub fn test_destroy_actually_kills(force: bool) {
     use std::io::process::{Command, ProcessOutput, ExitStatus, ExitSignal};
@@ -129,10 +100,10 @@ pub fn test_destroy_actually_kills(force: bool) {
     }
 }
 
-iotest!(fn test_unforced_destroy_actually_kills() {
+fn test_unforced_destroy_actually_kills() {
     test_destroy_actually_kills(false);
-})
+}
 
-iotest!(fn test_forced_destroy_actually_kills() {
+fn test_forced_destroy_actually_kills() {
     test_destroy_actually_kills(true);
-})
+}

src/test/run-pass/issue-12684.rs

@@ -8,18 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
-extern crate native;
-extern crate green;
-extern crate rustuv;
-
 use std::time::Duration;
 
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 fn main() {
     native::task::spawn(proc() customtask());
 }

src/test/run-pass/issue-13304.rs

@@ -10,48 +10,25 @@
 
 // ignore-fast
 
-extern crate green;
-extern crate rustuv;
-extern crate native;
-
 use std::os;
 use std::io;
 use std::str;
 
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 fn main() {
     let args = os::args();
     let args = args.as_slice();
     if args.len() > 1 && args[1].as_slice() == "child" {
-        if args[2].as_slice() == "green" {
+        child();
-            child();
-        } else {
-            let (tx, rx) = channel();
-            native::task::spawn(proc() { tx.send(child()); });
-            rx.recv();
-        }
     } else {
-        parent("green".to_string());
+        parent();
-        parent("native".to_string());
-        let (tx, rx) = channel();
-        native::task::spawn(proc() {
-            parent("green".to_string());
-            parent("native".to_string());
-            tx.send(());
-        });
-        rx.recv();
     }
 }
 
-fn parent(flavor: String) {
+fn parent() {
     let args = os::args();
     let args = args.as_slice();
     let mut p = io::process::Command::new(args[0].as_slice())
-                                     .arg("child").arg(flavor).spawn().unwrap();
+                                     .arg("child").spawn().unwrap();
     p.stdin.get_mut_ref().write_str("test1\ntest2\ntest3").unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(out.status.success());

src/test/run-pass/issue-13494.rs

@@ -11,22 +11,13 @@
 // This test may not always fail, but it can be flaky if the race it used to
 // expose is still present.
 
-extern crate green;
-extern crate rustuv;
-extern crate native;
-
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 fn helper(rx: Receiver<Sender<()>>) {
     for tx in rx.iter() {
         let _ = tx.send_opt(());
     }
 }
 
-fn test() {
+fn main() {
     let (tx, rx) = channel();
     spawn(proc() { helper(rx) });
     let (snd, rcv) = channel::<int>();
@@ -40,17 +31,3 @@ fn test() {
         }
     }
 }
-
-fn main() {
-    let (tx, rx) = channel();
-    spawn(proc() {
-        tx.send(test());
-    });
-    rx.recv();
-
-    let (tx, rx) = channel();
-    native::task::spawn(proc() {
-        tx.send(test());
-    });
-    rx.recv();
-}

src/test/run-pass/issue-14456.rs

@@ -8,19 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(phase)]
-
-#[phase(plugin, link)]
-extern crate green;
-extern crate native;
 
 use std::io::process;
 use std::io::Command;
 use std::io;
 use std::os;
 
-green_start!(main)
-
 fn main() {
     let args = os::args();
     if args.len() > 1 && args.get(1).as_slice() == "child" {
@@ -29,12 +22,6 @@ fn main() {
 
     test();
 
-    let (tx, rx) = channel();
-    native::task::spawn(proc() {
-        tx.send(test());
-    });
-    rx.recv();
-
 }
 
 fn child() {
@@ -52,4 +39,3 @@ fn test() {
                                      .spawn().unwrap();
     assert!(p.wait().unwrap().success());
 }
-

src/test/run-pass/issue-15149.rs

@@ -8,18 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(phase)]
-extern crate native;
-#[phase(plugin)]
-extern crate green;
-
-use native::NativeTaskBuilder;
 use std::io::{TempDir, Command, fs};
 use std::os;
 use std::task::TaskBuilder;
 
-green_start!(main)
-
 fn main() {
     // If we're the child, make sure we were invoked correctly
     let args = os::args();
@@ -28,11 +20,6 @@ fn main() {
     }
 
     test();
-    let (tx, rx) = channel();
-    TaskBuilder::new().native().spawn(proc() {
-        tx.send(test());
-    });
-    rx.recv();
 }
 
 fn test() {

src/test/run-pass/issue-16272.rs

@@ -8,28 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(phase)]
-#[phase(plugin)]
-extern crate green;
-extern crate native;
-
-use native::NativeTaskBuilder;
 use std::io::{process, Command};
 use std::os;
-use std::task::TaskBuilder;
-
-green_start!(main)
 
 fn main() {
     let len = os::args().len();
 
     if len == 1 {
         test();
-        let (tx, rx) = channel();
-        TaskBuilder::new().native().spawn(proc() {
-            tx.send(test());
-        });
-        rx.recv();
     } else {
         assert_eq!(len, 3);
     }

src/test/run-pass/process-detach.rs

@@ -19,19 +19,12 @@
 // Note that the first thing we do is put ourselves in our own process group so
 // we don't interfere with other running tests.
 
-extern crate green;
-extern crate rustuv;
 extern crate libc;
 
 use std::io::process;
 use std::io::process::Command;
 use std::io::signal::{Listener, Interrupt};
 
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 fn main() {
     unsafe { libc::setsid(); }
 

src/test/run-pass/tcp-accept-stress.rs

@@ -13,30 +13,14 @@
 //              quite quickly and it takes a few seconds for the sockets to get
 //              recycled.
 
-#![feature(phase)]
-
-#[phase(plugin)]
-extern crate green;
-extern crate native;
-
 use std::io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream};
 use std::sync::{atomic, Arc};
-use std::task::TaskBuilder;
-use native::NativeTaskBuilder;
 
 static N: uint = 8;
 static M: uint = 20;
 
-green_start!(main)
-
 fn main() {
     test();
-
-    let (tx, rx) = channel();
-    TaskBuilder::new().native().spawn(proc() {
-        tx.send(test());
-    });
-    rx.recv();
 }
 
 fn test() {
@@ -98,4 +82,3 @@ fn test() {
     // Everything should have been accepted.
     assert_eq!(cnt.load(atomic::SeqCst), N * M);
 }
-

src/test/run-pass/tcp-connect-timeouts.rs

@@ -20,40 +20,16 @@
 #![allow(experimental)]
 #![reexport_test_harness_main = "test_main"]
 
-extern crate native;
+#![allow(unused_imports)]
-extern crate green;
-extern crate rustuv;
 
-#[cfg(test)] #[start]
+use std::io::*;
-fn start(argc: int, argv: *const *const u8) -> int {
+use std::io::net::tcp::*;
-    green::start(argc, argv, rustuv::event_loop, test_main)
+use std::io::test::*;
-}
+use std::io;
+use std::time::Duration;
 
-macro_rules! iotest (
+#[cfg_attr(target_os = "freebsd", ignore)]
-    { fn $name:ident() $b:block $(#[$a:meta])* } => (
+fn eventual_timeout() {
-        mod $name {
-            #![allow(unused_imports)]
-
-            use std::io::*;
-            use std::io::net::tcp::*;
-            use std::io::test::*;
-            use std::io;
-            use std::time::Duration;
-
-            fn f() $b
-
-            $(#[$a])* #[test] fn green() { f() }
-            $(#[$a])* #[test] fn native() {
-                use native;
-                let (tx, rx) = channel();
-                native::task::spawn(proc() { tx.send(f()) });
-                rx.recv();
-            }
-        }
-    )
-)
-
-iotest!(fn eventual_timeout() {
     use native;
     let addr = next_test_ip4();
     let host = addr.ip.to_string();
@@ -80,30 +56,29 @@ iotest!(fn eventual_timeout() {
         }
     }
     fail!("never timed out!");
-} #[cfg_attr(target_os = "freebsd", ignore)])
+}
 
-iotest!(fn timeout_success() {
+fn timeout_success() {
     let addr = next_test_ip4();
     let host = addr.ip.to_string();
     let port = addr.port;
     let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen();
 
     assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(1000)).is_ok());
-})
+}
 
-iotest!(fn timeout_error() {
+fn timeout_error() {
     let addr = next_test_ip4();
 
     assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(1000)).is_err());
-})
+}
 
-    iotest!(fn connect_timeout_zero() {
+fn connect_timeout_zero() {
-        let addr = next_test_ip4();
+    let addr = next_test_ip4();
-        assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(0)).is_err());
+    assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(0)).is_err());
-    })
+}
-
-    iotest!(fn connect_timeout_negative() {
-        let addr = next_test_ip4();
-        assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(-1)).is_err());
-    })
 
+fn connect_timeout_negative() {
+    let addr = next_test_ip4();
+    assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(-1)).is_err());
+}

src/test/run-pass/tcp-stress.rs

@@ -16,8 +16,6 @@
 #[phase(plugin, link)]
 extern crate log;
 extern crate libc;
-extern crate green;
-extern crate rustuv;
 extern crate debug;
 
 use std::io::net::tcp::{TcpListener, TcpStream};
@@ -25,11 +23,6 @@ use std::io::{Acceptor, Listener};
 use std::task::TaskBuilder;
 use std::time::Duration;
 
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, main)
-}
-
 fn main() {
     // This test has a chance to time out, try to not let it time out
     spawn(proc() {