Removed trans_comm.rs from the compiler. Updating aio/sio to work with the new chan and port system, started on a networking module for the standard library.

16 files changed, 118 insertions, 107 deletions

diff --git a/src/test/compile-fail/bad-recv.rs b/src/test/compile-fail/bad-recv.rs
deleted file mode 100644
index d97d358d9e0..00000000000
--- a/src/test/compile-fail/bad-recv.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-// error-pattern: mismatched types
-
-fn main() { 10 |> 10; }
\ No newline at end of file
diff --git a/src/test/compile-fail/bad-send.rs b/src/test/compile-fail/bad-send.rs
deleted file mode 100644
index deb7a744c60..00000000000
--- a/src/test/compile-fail/bad-send.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-// error-pattern: mismatched types
-
-fn main() { 10 <| 10; }
\ No newline at end of file
diff --git a/src/test/compile-fail/binop-shift-port.rs b/src/test/compile-fail/binop-shift-port.rs
deleted file mode 100644
index e1b49d75ddb..00000000000
--- a/src/test/compile-fail/binop-shift-port.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// error-pattern:>> cannot be applied to type `port[int]`
-
-fn main() {
-    let p1: port[int] = port();
-    let p2: port[int] = port();
-    let x = p1 >> p2;
-}
\ No newline at end of file
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index f7932c93a27..4fbb0d1498b 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -5,11 +5,12 @@
 
 use std;
 import std::task;
+import std::comm::mk_port;
 
 fn child() { assert (1 == 2); }
 
 fn main() {
-    let p: port[int] = port();
+    let p = mk_port[int]();
     task::_spawn(bind child());
-    let x: int; p |> x;
+    let x = p.recv();
 }
diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs
index cadb8ef387d..bacb7f9effc 100644
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -1,13 +1,17 @@
 // error-pattern:meep
-fn echo[T](c: chan[T], oc: chan[chan[T]]) {
+use std;
+import std::comm::_chan;
+import std::comm::mk_port;
+import std::comm::send;
+
+fn echo[~T](c: _chan[T], oc: _chan[_chan[T]]) {
     // Tests that the type argument in port gets
     // visited
-    let p = port[T]();
-    oc <| chan(p);
+    let p = mk_port[T]();
+    send(oc, p.mk_chan());
 
-    let x;
-    p |> x;
-    c <| x;
+    let x = p.recv();
+    send(c, x);
 }
 
-fn main() { fail "meep"; }
\ No newline at end of file
+fn main() { fail "meep"; }
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index b5a852611ad..f6f2f5be7e5 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -3,6 +3,7 @@
 use std;
 import std::unsafe::reinterpret_cast;
 import std::task;
+import std::comm;
 
 fn test_nil() {
     assert (() == ());
@@ -60,20 +61,21 @@ fn test_box() {
 }
 
 fn test_port() {
-    let p1: port[int] = port();
-    let p2: port[int] = port();
+    let p1 = comm::mk_port[int]();
+    let p2 = comm::mk_port[int]();
 
     assert p1 == p1;
     assert p1 != p2;
 }
 
 fn test_chan() {
-    let p: port[int] = port();
-    let ch1 = chan(p);
-    let ch2 = chan(p);
+    let p: comm::_port[int] = comm::mk_port();
+    let ch1 = p.mk_chan();
+    let ch2 = p.mk_chan();
 
     assert ch1 == ch1;
-    assert ch1 != ch2;
+    // Chans are equal because they are just task:port addresses.
+    assert ch1 == ch2;
 }
 
 fn test_ptr() {
diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs
index 6f24675d795..e078bef7131 100644
--- a/src/test/run-pass/decl-with-recv.rs
+++ b/src/test/run-pass/decl-with-recv.rs
@@ -1,16 +1,16 @@
+// -*- rust -*-
 
+use std;
+import std::comm::mk_port;
+import std::comm::send;
 
-
-// -*- rust -*-
 fn main() {
-    let po: port[int] = port();
-    let ch: chan[int] = chan(po);
-    ch <| 10;
-    let i: int;
-    po |> i;
+    let po = mk_port();
+    let ch = po.mk_chan();
+    send(ch, 10);
+    let i = po.recv();
     assert (i == 10);
-    ch <| 11;
-    let j;
-    po |> j;
+    send(ch, 11);
+    let j = po.recv();
     assert (j == 11);
 }
\ No newline at end of file
diff --git a/src/test/run-pass/obj-docs.rs b/src/test/run-pass/obj-docs.rs
index 4c2d34555c4..a7cb03906ed 100644
--- a/src/test/run-pass/obj-docs.rs
+++ b/src/test/run-pass/obj-docs.rs
@@ -1,5 +1,9 @@
 // Sanity-check the code examples that appear in the object system
 // documentation.
+use std;
+import std::comm::_chan;
+import std::comm::send;
+import std::comm::mk_port;
 
 fn main() {
 
@@ -43,9 +47,9 @@ fn main() {
         }
     }
 
-    obj sender(c: chan[int]) {
+    obj sender(c: _chan[int]) {
         fn take(z: int) {
-            c <| z;
+            send(c, z);
         }
     }
 
@@ -55,10 +59,10 @@ fn main() {
         t.take(3);
     }
 
-    let p: port[int] = port();
+    let p = mk_port[int]();
 
     let t1: taker = adder(@mutable 0);
-    let t2: taker = sender(chan(p));
+    let t2: taker = sender(p.mk_chan());
 
     give_ints(t1);
     give_ints(t2);
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index 2490b4a45ec..11b67593bd6 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -1,5 +1,3 @@
-
-
 // -*- rust -*-
 
 // Regression tests for circular_buffer when using a unit
@@ -7,7 +5,9 @@
 use std;
 import std::option;
 import std::uint;
-
+import std::comm;
+import std::comm::mk_port;
+import std::comm::send;
 
 // A 12-byte unit to send over the channel
 type record = {val1: u32, val2: u32, val3: u32};
@@ -18,50 +18,52 @@ type record = {val1: u32, val2: u32, val3: u32};
 // power of two so needs to be rounded up. Don't trigger any
 // assertions.
 fn test_init() {
-    let myport: port[record] = port();
-    let mychan = chan(myport);
+    let myport = mk_port[record]();
+    let mychan = myport.mk_chan();
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    mychan <| val;
+    send(mychan, val);
 }
 
 
 // Dump lots of items into the channel so it has to grow.
 // Don't trigger any assertions.
 fn test_grow() {
-    let myport: port[record] = port();
-    let mychan = chan(myport);
-    let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    for each i: uint in uint::range(0u, 100u) { mychan <| val; }
+    let myport: comm::_port[record] = comm::mk_port();
+    let mychan = myport.mk_chan();
+    for each i: uint  in uint::range(0u, 100u) {
+        let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
+        comm::send(mychan, val);
+    }
 }
 
 
 // Don't allow the buffer to shrink below it's original size
 fn test_shrink1() {
-    let myport: port[i8] = port();
-    let mychan = chan(myport);
-    mychan <| 0i8;
-    let x;
-    myport |> x;
+    let myport = comm::mk_port[i8]();
+    let mychan = myport.mk_chan();
+    send(mychan, 0i8);
+    let x = myport.recv();
 }
 
 fn test_shrink2() {
-    let myport: port[record] = port();
-    let mychan = chan(myport);
-    let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
-    for each i: uint in uint::range(0u, 100u) { mychan <| val; }
-    for each i: uint in uint::range(0u, 100u) { let x; myport |> x; }
+    let myport = mk_port[record]();
+    let mychan = myport.mk_chan();
+    for each i: uint  in uint::range(0u, 100u) {
+        let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
+        send(mychan, val);
+    }
+    for each i: uint  in uint::range(0u, 100u) { let x = myport.recv(); }
 }
 
 
 // Test rotating the buffer when the unit size is not a power of two
 fn test_rotate() {
-    let myport: port[record] = port();
-    let mychan = chan(myport);
-    for each i: uint in uint::range(0u, 100u) {
+    let myport = mk_port[record]();
+    let mychan = myport.mk_chan();
+    for each i: uint  in uint::range(0u, 100u) {
         let val = {val1: i as u32, val2: i as u32, val3: i as u32};
-        mychan <| val;
-        let x;
-        myport |> x;
+        send(mychan, val);
+        let x = myport.recv();
         assert (x.val1 == i as u32);
         assert (x.val2 == i as u32);
         assert (x.val3 == i as u32);
@@ -72,17 +74,16 @@ fn test_rotate() {
 // Test rotating and growing the buffer when
 // the unit size is not a power of two
 fn test_rotate_grow() {
-    let myport: port[record] = port();
-    let mychan = chan(myport);
-    for each j: uint in uint::range(0u, 10u) {
-        for each i: uint in uint::range(0u, 10u) {
+    let myport = mk_port[record]();
+    let mychan = myport.mk_chan();
+    for each j: uint  in uint::range(0u, 10u) {
+        for each i: uint  in uint::range(0u, 10u) {
             let val: record =
                 {val1: i as u32, val2: i as u32, val3: i as u32};
-            mychan <| val;
+            send(mychan, val);
         }
-        for each i: uint in uint::range(0u, 10u) {
-            let x;
-            myport |> x;
+        for each i: uint  in uint::range(0u, 10u) {
+            let x = myport.recv();
             assert (x.val1 == i as u32);
             assert (x.val2 == i as u32);
             assert (x.val3 == i as u32);
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index 62380988336..c689c479bac 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/src/test/run-pass/send-type-inference.rs
@@ -1,8 +1,13 @@
+use std;
+import std::comm::_chan;
+import std::comm::send;
+import std::comm::mk_port;
+
 // tests that ctrl's type gets inferred properly
 type command[K, V] = {key: K, val: V};
 
-fn cache_server[K, V](c: chan[chan[command[K, V]]]) {
-    let ctrl = port();
-    c <| chan(ctrl);
+fn cache_server[K, V](c: _chan[_chan[command[K, V]]]) {
+    let ctrl = mk_port[_chan[command[K, V]]]();
+    send(c, ctrl.mk_chan());
 }
 fn main() { }
\ No newline at end of file
diff --git a/src/test/run-pass/sio-client.rs b/src/test/run-pass/sio-client.rs
index c392e21896a..a5667ff0616 100644
--- a/src/test/run-pass/sio-client.rs
+++ b/src/test/run-pass/sio-client.rs
@@ -1,12 +1,12 @@
 // xfail-stage1
 // xfail-stage2
 // xfail-stage3
-
 use std;
 import std::sio;
 import std::task;
+import std::net;
 
-fn connectTask(cx: sio::ctx, ip: str, portnum: int) {
+fn connectTask(cx: sio::ctx, ip: net::ip_addr, portnum: int) {
   let client: sio::client;
   client = sio::connect_to(cx, ip, portnum);
   sio::close_client(client);
@@ -14,10 +14,13 @@ fn connectTask(cx: sio::ctx, ip: str, portnum: int) {
 
 fn main() {
   let cx: sio::ctx = sio::new();
-  let srv: sio::server = sio::create_server(cx, "0.0.0.0", 9090);
-  let child: task = spawn connectTask(cx, "127.0.0.1", 9090);
+  let srv: sio::server = sio::create_server(cx,
+                                            net::parse_addr("0.0.0.0"), 9090);
+  let child = task::_spawn(bind connectTask(cx,
+                                            net::parse_addr("127.0.0.1"),
+                                            9090));
   let client: sio::client = sio::accept_from(srv);
-  task::join(child);
+  task::join_id(child);
   sio::close_client(client);
   sio::close_server(srv);
   sio::destroy(cx);
diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs
index 2cdd2c596cb..be8018d4278 100644
--- a/src/test/run-pass/task-comm-chan-nil.rs
+++ b/src/test/run-pass/task-comm-chan-nil.rs
@@ -1,16 +1,15 @@
-
-
-
 // -*- rust -*-
 
+use std;
+import std::comm;
+
 // rustboot can't transmit nils across channels because they don't have
 // any size, but rustc currently can because they do have size. Whether
 // or not this is desirable I don't know, but here's a regression test.
 fn main() {
-    let po: port[()] = port();
-    let ch: chan[()] = chan(po);
-    ch <| ();
-    let n: ();
-    po |> n;
+    let po: comm::_port[()] = comm::mk_port();
+    let ch: comm::_chan[()] = po.mk_chan();
+    comm::send(ch, ());
+    let n: () = po.recv();
     assert (n == ());
 }
\ No newline at end of file
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index e5f25d6ec3e..61e36b171e2 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -1,15 +1,15 @@
-
-
+use std;
+import std::comm::mk_port;
+import std::comm::send;
 
 /*
   This is about the simplest program that can successfully send a
   message.
  */
 fn main() {
-    let po: port[int] = port();
-    let ch: chan[int] = chan(po);
-    ch <| 42;
-    let r;
-    po |> r;
+    let po = mk_port[int]();
+    let ch = po.mk_chan();
+    send(ch, 42);
+    let r = po.recv();
     log_err r;
 }
\ No newline at end of file
diff --git a/src/test/stdtest/net.rs b/src/test/stdtest/net.rs
new file mode 100644
index 00000000000..c1a26cb747d
--- /dev/null
+++ b/src/test/stdtest/net.rs
@@ -0,0 +1,12 @@
+use std;
+import std::net;
+
+#[test]
+fn test_format_ip() {
+    assert(net::format_addr(net::ipv4(127u8,0u8,0u8,1u8)) == "127.0.0.1")
+}
+
+#[test]
+fn test_parse_ip() {
+    assert(net::parse_addr("127.0.0.1") == net::ipv4(127u8,0u8,0u8,1u8));
+}
diff --git a/src/test/stdtest/stdtest.rc b/src/test/stdtest/stdtest.rc
index 401587ed36e..cda3b939eb3 100644
--- a/src/test/stdtest/stdtest.rc
+++ b/src/test/stdtest/stdtest.rc
@@ -12,6 +12,7 @@ mod io;
 mod ivec;
 mod list;
 mod map;
+mod net;
 mod option;
 mod os;
 mod path;
diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index 4d689bcb36a..56b555232a9 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -26,14 +26,6 @@ fn test_join() {
 }
 
 #[test]
-fn test_send_recv() {
-    let p = port[int]();
-    let c = chan(p);
-    task::send(c, 10);
-    assert (task::recv(p) == 10);
-}
-
-#[test]
 fn test_lib_spawn() {
     fn foo() { log_err "Hello, World!"; }
     task::_spawn(foo);