Camel case various core constructors

61 files changed, 182 insertions, 198 deletions

diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs
index b4dda9cf5e2..a022ee63273 100644
--- a/src/test/auxiliary/cci_capture_clause.rs
+++ b/src/test/auxiliary/cci_capture_clause.rs
@@ -3,8 +3,8 @@ export foo;
 import comm::*;
 
 fn foo<T: send copy>(x: T) -> Port<T> {
-    let p = port();
-    let c = chan(p);
+    let p = Port();
+    let c = Chan(p);
     do task::spawn() |copy c, copy x| {
         c.send(x);
     }
diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs
index b96745890f9..ff468be9540 100644
--- a/src/test/auxiliary/cci_nested_lib.rs
+++ b/src/test/auxiliary/cci_nested_lib.rs
@@ -1,4 +1,4 @@
-import dvec::{DVec, dvec};
+import dvec::DVec;
 
 type entry<A,B> = {key: A, value: B};
 type alist<A,B> = { eq_fn: fn@(A,A) -> bool, data: DVec<entry<A,B>> };
@@ -18,12 +18,12 @@ fn alist_get<A: copy, B: copy>(lst: alist<A,B>, k: A) -> B {
 #[inline]
 fn new_int_alist<B: copy>() -> alist<int, B> {
     fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-    return {eq_fn: eq_int, data: dvec()};
+    return {eq_fn: eq_int, data: DVec()};
 }
 
 #[inline]
 fn new_int_alist_2<B: copy>() -> alist<int, B> {
     #[inline]
     fn eq_int(&&a: int, &&b: int) -> bool { a == b }
-    return {eq_fn: eq_int, data: dvec()};
+    return {eq_fn: eq_int, data: DVec()};
 }
\ No newline at end of file
diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index 9a267a5a25d..8daa79991d9 100644
--- a/src/test/bench/core-map.rs
+++ b/src/test/bench/core-map.rs
@@ -168,10 +168,10 @@ fn main(args: ~[~str]) {
         let rng = rand::seeded_rng(copy seed);
         let mut results = empty_results();
         int_benchmarks::<Managed<LinearMap<uint, uint>>>(
-            || Managed(linear_map(uint::hash, uint::eq)),
+            || Managed(LinearMap(uint::hash, uint::eq)),
             rng, num_keys, &mut results);
         str_benchmarks::<Managed<LinearMap<~str, uint>>>(
-            || Managed(linear_map(str::hash, str::eq)),
+            || Managed(LinearMap(str::hash, str::eq)),
             rng, num_keys, &mut results);
         write_results("libstd::map::hashmap", &results);
     }
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index 1e7f4077d33..2cea9d14cdd 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -64,7 +64,7 @@ fn read_line() {
 }
 
 fn str_set() {
-    let r = rand::rng();
+    let r = rand::Rng();
 
     let s = map::hashmap(str::hash, str::eq);
 
@@ -82,7 +82,7 @@ fn str_set() {
 }
 
 fn vec_plus() {
-    let r = rand::rng();
+    let r = rand::Rng();
 
     let mut v = ~[]; 
     let mut i = 0;
@@ -99,7 +99,7 @@ fn vec_plus() {
 }
 
 fn vec_append() {
-    let r = rand::rng();
+    let r = rand::Rng();
 
     let mut v = ~[];
     let mut i = 0;
@@ -116,7 +116,7 @@ fn vec_append() {
 }
 
 fn vec_push_all() {
-    let r = rand::rng();
+    let r = rand::Rng();
 
     let mut v = ~[];
     for uint::range(0, 1500) |i| {
diff --git a/src/test/bench/core-vec-append.rs b/src/test/bench/core-vec-append.rs
index a9641acf45d..fe65bcaf623 100644
--- a/src/test/bench/core-vec-append.rs
+++ b/src/test/bench/core-vec-append.rs
@@ -1,7 +1,7 @@
 // A raw test of vector appending performance.
 
 use std;
-import dvec::dvec;
+import dvec::DVec;
 import io::WriterUtil;
 
 fn collect_raw(num: uint) -> ~[uint] {
@@ -13,7 +13,7 @@ fn collect_raw(num: uint) -> ~[uint] {
 }
 
 fn collect_dvec(num: uint) -> ~[mut uint] {
-    let result = dvec();
+    let result = DVec();
     for uint::range(0u, num) |i| {
         result.push(i);
     }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 44588a1ecdb..b30a2c4eac9 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -88,7 +88,7 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
 
 fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] {
     let keys = map::hashmap::<node_id, ()>(node_hash, sys::shape_eq);
-    let r = rand::rng();
+    let r = rand::Rng();
 
     while keys.size() < n {
         let k = r.gen_uint_range(0u, graph.len());
diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs
index d3fdc472b66..05590037f0b 100644
--- a/src/test/bench/msgsend-ring.rs
+++ b/src/test/bench/msgsend-ring.rs
@@ -33,8 +33,8 @@ fn main(args: ~[~str]) {
     let num_tasks = option::get(uint::from_str(args[1]));
     let msg_per_task = option::get(uint::from_str(args[2]));
 
-    let num_port = port();
-    let mut num_chan = chan(num_port);
+    let num_port = Port();
+    let mut num_chan = Chan(num_port);
 
     let start = time::precise_time_s();
 
@@ -42,12 +42,12 @@ fn main(args: ~[~str]) {
     let mut futures = ~[];
 
     for uint::range(1u, num_tasks) |i| {
-        let get_chan = port();
-        let get_chan_chan = chan(get_chan);
+        let get_chan = Port();
+        let get_chan_chan = Chan(get_chan);
 
         futures += ~[do future::spawn |copy num_chan, move get_chan_chan| {
-            let p = port();
-            get_chan_chan.send(chan(p));
+            let p = Port();
+            get_chan_chan.send(Chan(p));
             thread_ring(i, msg_per_task, num_chan,  p)
         }];
         
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 4895e4dc24e..a4ac4794bd3 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -122,12 +122,12 @@ fn creature(
 
 fn rendezvous(nn: uint, set: ~[color]) {
     // these ports will allow us to hear from the creatures
-    let from_creatures:     comm::Port<creature_info> = comm::port();
-    let from_creatures_log: comm::Port<~str> = comm::port();
+    let from_creatures:     comm::Port<creature_info> = comm::Port();
+    let from_creatures_log: comm::Port<~str> = comm::Port();
 
     // these channels will be passed to the creatures so they can talk to us
-    let to_rendezvous     = comm::chan(from_creatures);
-    let to_rendezvous_log = comm::chan(from_creatures_log);
+    let to_rendezvous     = comm::Chan(from_creatures);
+    let to_rendezvous_log = comm::Chan(from_creatures_log);
 
     // these channels will allow us to talk to each creature by 'name'/index
     let to_creature: ~[comm::Chan<Option<creature_info>>] =
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index b9dc89c43c5..896ec6729b0 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -45,7 +45,7 @@ fn select_random(r: u32, genelist: ~[aminoacids]) -> char {
 
 fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[aminoacids], n: int) {
     wr.write_line(~">" + id + ~" " + desc);
-    let rng = @{mut last: rand::rng().next()};
+    let rng = @{mut last: rand::Rng().next()};
     let mut op: ~str = ~"";
     for uint::range(0u, n as uint) |_i| {
         str::push_char(op, select_random(myrandom_next(rng, 100u32),
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 20110e60998..206c91da7de 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -138,8 +138,8 @@ fn main(args: ~[~str]) {
 
    // initialize each sequence sorter
    let sizes = ~[1u,2u,3u,4u,6u,12u,18u];
-   let from_child = vec::map (sizes, |_sz| comm::port() );
-   let to_parent  = vec::mapi(sizes, |ii, _sz| comm::chan(from_child[ii]) );
+   let from_child = vec::map (sizes, |_sz| comm::Port() );
+   let to_parent  = vec::mapi(sizes, |ii, _sz| comm::Chan(from_child[ii]) );
    let to_child   = vec::mapi(sizes, fn@(ii: uint, sz: uint) -> comm::Chan<~[u8]> {
        return do task::spawn_listener |from_parent| {
          make_sequence_processor(sz, from_parent, to_parent[ii]);
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index 1d1c2e2ac29..fc011952be3 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -100,8 +100,8 @@ impl devnull: io::Writer {
 
 fn writer(path: ~str, writech: comm::Chan<comm::Chan<line>>, size: uint)
 {
-    let p: comm::Port<line> = comm::port();
-    let ch = comm::chan(p);
+    let p: comm::Port<line> = comm::Port();
+    let ch = comm::Chan(p);
     comm::send(writech, ch);
     let cout: io::Writer = match path {
         ~"" => {
@@ -168,8 +168,8 @@ fn main(args: ~[~str]) {
     let size = if vec::len(args) < 2_u { 80_u }
     else { uint::from_str(args[1]).get() };
 
-    let writep = comm::port();
-    let writech = comm::chan(writep);
+    let writep = comm::Port();
+    let writech = comm::Chan(writep);
     do task::spawn {
         writer(path, writech, size);
     };
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 91b2c6e5dc8..702f53e5693 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -6,8 +6,8 @@ const n_threads: int = 503;
 fn start(+token: int) {
     import iter::*;
 
-    let p = comm::port();
-    let mut ch = comm::chan(p);
+    let p = comm::Port();
+    let mut ch = comm::Chan(p);
     for int::range(2, n_threads + 1) |i| {
         let id = n_threads + 2 - i;
         let to_child = do task::spawn_listener::<int> |p, copy ch| {
diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs
index 2fb2cfe1da9..c2ebfc785df 100644
--- a/src/test/bench/task-perf-linked-failure.rs
+++ b/src/test/bench/task-perf-linked-failure.rs
@@ -10,13 +10,13 @@
 // Creates in the background 'num_tasks' tasks, all blocked forever.
 // Doesn't return until all such tasks are ready, but doesn't block forever itself.
 fn grandchild_group(num_tasks: uint) {
-    let po = comm::port();
-    let ch = comm::chan(po);
+    let po = comm::Port();
+    let ch = comm::Chan(po);
 
     for num_tasks.times {
         do task::spawn { // linked
             comm::send(ch, ());
-            comm::recv(comm::port::<()>()); // block forever
+            comm::recv(comm::Port::<()>()); // block forever
         }
     }
     #error["Grandchild group getting started"];
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index a9604c7c533..86b23d126cf 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -7,8 +7,8 @@ enum msg {
 }
 
 fn calc(children: uint, parent_ch: comm::Chan<msg>) {
-    let port = comm::port();
-    let chan = comm::chan(port);
+    let port = comm::Port();
+    let chan = comm::Chan(port);
     let mut child_chs = ~[];
     let mut sum = 0;
 
@@ -58,8 +58,8 @@ fn main(args: ~[~str]) {
     };
 
     let children = uint::from_str(args[1]).get();
-    let port = comm::port();
-    let chan = comm::chan(port);
+    let port = comm::Port();
+    let chan = comm::Chan(port);
     do task::spawn {
         calc(children, chan);
     };
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 73b24dd2b54..0c175ab4e2c 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -28,9 +28,7 @@ import u64;
 import task;
 import comm;
 import comm::Chan;
-import comm::chan;
 import comm::Port;
-import comm::port;
 import comm::recv;
 import comm::send;
 
@@ -62,8 +60,8 @@ impl ~str: hash_key {
 // These used to be in task, but they disappeard.
 type joinable_task = Port<()>;
 fn spawn_joinable(+f: fn~()) -> joinable_task {
-    let p = port();
-    let c = chan(p);
+    let p = Port();
+    let c = Chan(p);
     do task::spawn() |move f| {
         f();
         c.send(());
@@ -214,9 +212,9 @@ mod map_reduce {
         key: K,
         out: Chan<Chan<reduce_proto<V>>>)
     {
-        let p = port();
+        let p = Port();
 
-        send(out, chan(p));
+        send(out, Chan(p));
 
         let mut ref_count = 0;
         let mut is_done = false;
@@ -277,8 +275,8 @@ mod map_reduce {
                   }
                   None => {
                     // log(error, "creating new reducer for " + k);
-                    let p = port();
-                    let ch = chan(p);
+                    let p = Port();
+                    let ch = Chan(p);
                     let r = reduce, kk = k;
                     vec::push(tasks,
                               spawn_joinable(|| reduce_task(r, kk, ch) ));
@@ -355,7 +353,7 @@ struct random_word_reader: word_reader {
     let rng: rand::Rng;
     new(count: uint) {
         self.remaining = count;
-        self.rng = rand::rng();
+        self.rng = rand::Rng();
     }
 
     fn read_word() -> Option<~str> {
diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs
index 2bf2155e4c5..2a6c26e9f13 100644
--- a/src/test/compile-fail/no-send-res-ports.rs
+++ b/src/test/compile-fail/no-send-res-ports.rs
@@ -5,7 +5,7 @@ fn main() {
       drop {}
     }
    
-    let x = ~mut Some(foo(comm::port()));
+    let x = ~mut Some(foo(comm::Port()));
 
     do task::spawn |move x| { //~ ERROR not a sendable value
         let mut y = None;
diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs
index 7a724ff3d5c..29d89fbf860 100644
--- a/src/test/compile-fail/unsendable-class.rs
+++ b/src/test/compile-fail/unsendable-class.rs
@@ -9,7 +9,7 @@ struct foo {
 
 fn main() {
   let cat = ~"kitty";
-  let po = comm::port();         //~ ERROR missing `send`
-  let ch = comm::chan(po);       //~ ERROR missing `send`
+  let po = comm::Port();         //~ ERROR missing `send`
+  let ch = comm::Chan(po);       //~ ERROR missing `send`
   comm::send(ch, foo(42, @cat)); //~ ERROR missing `send`
 }
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 6189567d017..8b1f2588274 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -3,13 +3,13 @@
 // error-pattern:1 == 2
 use std;
 import task;
-import comm::port;
+import comm::Port;
 import comm::recv;
 
 fn child() { assert (1 == 2); }
 
 fn main() {
-    let p = port::<int>();
+    let p = Port::<int>();
     task::spawn(|| child() );
     let x = recv(p);
 }
diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index f2ad8fb39ea..cdb4dd446a1 100644
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -3,14 +3,14 @@
 // error-pattern:fail
 use std;
 import task;
-import comm::chan;
-import comm::port;
+import comm::Chan;
+import comm::Port;
 import comm::recv;
 
 fn child() { fail; }
 
 fn main() {
-    let p = port::<int>();
+    let p = Port::<int>();
     task::spawn(|| child() );
     task::yield();
 }
diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index 926317c7836..2acb1494078 100644
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -3,19 +3,19 @@
 // error-pattern:fail
 use std;
 import task;
-import comm::port;
+import comm::Port;
 import comm::recv;
 
 fn grandchild() { fail ~"grandchild dies"; }
 
 fn child() {
-    let p = port::<int>();
+    let p = Port::<int>();
     task::spawn(|| grandchild() );
     let x = recv(p);
 }
 
 fn main() {
-    let p = port::<int>();
+    let p = Port::<int>();
     task::spawn(|| child() );
     let x = recv(p);
 }
diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index fb7d596145d..4808ab70976 100644
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -2,14 +2,14 @@
 // error-pattern:1 == 2
 use std;
 import task;
-import comm::chan;
-import comm::port;
+import comm::Chan;
+import comm::Port;
 import comm::recv;
 
 fn child() { assert (1 == 2); }
 
 fn parent() {
-    let p = port::<int>();
+    let p = Port::<int>();
     task::spawn(|| child() );
     let x = recv(p);
 }
@@ -17,7 +17,7 @@ fn parent() {
 // This task is not linked to the failure chain, but since the other
 // tasks are going to fail the kernel, this one will fail too
 fn sleeper() {
-    let p = port::<int>();
+    let p = Port::<int>();
     let x = recv(p);
 }
 
diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs
index 835fc7acba4..17b03ed53cf 100644
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -1,16 +1,15 @@
 // error-pattern:meep
 use std;
 import comm::Chan;
-import comm::chan;
-import comm::port;
+import comm::Port;
 import comm::send;
 import comm::recv;
 
 fn echo<T: send>(c: Chan<T>, oc: Chan<Chan<T>>) {
     // Tests that the type argument in port gets
     // visited
-    let p = port::<T>();
-    send(oc, chan(p));
+    let p = Port::<T>();
+    send(oc, Chan(p));
 
     let x = recv(p);
     send(c, x);
diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index f55758d7196..1dc0561fc54 100644
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -11,7 +11,7 @@ fn goodfail() {
 
 fn main() {
     task::spawn(|| goodfail() );
-    let po = comm::port();
+    let po = comm::Port();
     // We shouldn't be able to get past this recv since there's no
     // message available
     let i: int = comm::recv(po);
diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs
index a3df02fd686..d1447f3bc60 100644
--- a/src/test/run-pass/basic-1.rs
+++ b/src/test/run-pass/basic-1.rs
@@ -2,8 +2,7 @@
 
 use std;
 import comm::Chan;
-import comm::chan;
-import comm::port;
+import comm::Port;
 import comm::send;
 import comm::recv;
 import task;
@@ -11,8 +10,8 @@ import task;
 fn a(c: Chan<int>) { send(c, 10); }
 
 fn main() {
-    let p = port();
-    let ch = chan(p);
+    let p = Port();
+    let ch = Chan(p);
     task::spawn(|| a(ch) );
     task::spawn(|| a(ch) );
     let mut n: int = 0;
diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs
index 2f0fe8fe006..c4719299b07 100644
--- a/src/test/run-pass/basic-2.rs
+++ b/src/test/run-pass/basic-2.rs
@@ -2,18 +2,17 @@
 
 use std;
 import comm;
-import comm::port;
+import comm::Port;
 import comm::send;
 import comm::Chan;
-import comm::chan;
 import comm::recv;
 import task;
 
 fn a(c: Chan<int>) { debug!("task a0"); debug!("task a1"); send(c, 10); }
 
 fn main() {
-    let p = port();
-    let ch = chan(p);
+    let p = Port();
+    let ch = Chan(p);
     task::spawn(|| a(ch) );
     task::spawn(|| b(ch) );
     let mut n: int = 0;
diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index abef48171ab..5e436208897 100644
--- a/src/test/run-pass/basic.rs
+++ b/src/test/run-pass/basic.rs
@@ -4,7 +4,6 @@ use std;
 import comm;
 import comm::send;
 import comm::Chan;
-import comm::chan;
 import comm::recv;
 import task;
 
@@ -31,8 +30,8 @@ fn g(x: int, y: ~str) -> int {
 fn main() {
     let mut n: int = 2 + 3 * 7;
     let s: ~str = ~"hello there";
-    let p = comm::port();
-    let ch = comm::chan(p);
+    let p = comm::Port();
+    let ch = comm::Chan(p);
     task::spawn(|| a(ch) );
     task::spawn(|| b(ch) );
     let mut x: int = 10;
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 2a2a3c3c612..0542faafb42 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -60,17 +60,17 @@ fn test_box() {
 }
 
 fn test_port() {
-    let p1 = comm::port::<int>();
-    let p2 = comm::port::<int>();
+    let p1 = comm::Port::<int>();
+    let p2 = comm::Port::<int>();
 
     assert (p1 == p1);
     assert (p1 != p2);
 }
 
 fn test_chan() {
-    let p: comm::Port<int> = comm::port();
-    let ch1 = comm::chan(p);
-    let ch2 = comm::chan(p);
+    let p: comm::Port<int> = comm::Port();
+    let ch1 = comm::Chan(p);
+    let ch2 = comm::Chan(p);
 
     assert (ch1 == ch1);
     // Chans are equal because they are just task:port addresses.
diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index 8902bcaf537..8b887c28ccc 100644
--- a/src/test/run-pass/chan-leak.rs
+++ b/src/test/run-pass/chan-leak.rs
@@ -3,10 +3,9 @@
 use std;
 import task;
 import comm::Chan;
-import comm::chan;
 import comm::send;
 import comm;
-import comm::port;
+import comm::Port;
 import comm::recv;
 
 enum request { quit, close(Chan<bool>), }
@@ -14,8 +13,8 @@ enum request { quit, close(Chan<bool>), }
 type ctx = Chan<request>;
 
 fn request_task(c: Chan<ctx>) {
-    let p = port();
-    send(c, chan(p));
+    let p = Port();
+    send(c, Chan(p));
     let mut req: request;
     req = recv(p);
     // Need to drop req before receiving it again
@@ -23,8 +22,8 @@ fn request_task(c: Chan<ctx>) {
 }
 
 fn new_cx() -> ctx {
-    let p = port();
-    let ch = chan(p);
+    let p = Port();
+    let ch = Chan(p);
     let t = task::spawn(|| request_task(ch) );
     let mut cx: ctx;
     cx = recv(p);
@@ -34,7 +33,7 @@ fn new_cx() -> ctx {
 fn main() {
     let cx = new_cx();
 
-    let p = port::<bool>();
-    send(cx, close(chan(p)));
+    let p = Port::<bool>();
+    send(cx, close(Chan(p)));
     send(cx, quit);
 }
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index 833552ccbf8..83109235433 100644
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -3,14 +3,13 @@
 use std;
 import comm;
 import comm::Chan;
-import comm::chan;
 import comm::send;
 import comm::recv;
 import task;
 
 fn main() {
-    let p = comm::port();
-    let ch = comm::chan(p);
+    let p = comm::Port();
+    let ch = comm::Chan(p);
     let t = task::spawn(|| child(ch) );
     let y = recv(p);
     error!("received");
diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs
index 7cee261e1cb..2d1ce1b2565 100644
--- a/src/test/run-pass/decl-with-recv.rs
+++ b/src/test/run-pass/decl-with-recv.rs
@@ -1,14 +1,14 @@
 // -*- rust -*-
 
 use std;
-import comm::port;
-import comm::chan;
+import comm::Port;
+import comm::Chan;
 import comm::send;
 import comm::recv;
 
 fn main() {
-    let po = port();
-    let ch = chan(po);
+    let po = Port();
+    let ch = Chan(po);
     send(ch, 10);
     let i = recv(po);
     assert (i == 10);
diff --git a/src/test/run-pass/dvec-index-op.rs b/src/test/run-pass/dvec-index-op.rs
index f6fa8f9332e..6a3688607e0 100644
--- a/src/test/run-pass/dvec-index-op.rs
+++ b/src/test/run-pass/dvec-index-op.rs
@@ -1,5 +1,5 @@
 fn main() {
-    let x = dvec::dvec();
+    let x = dvec::DVec();
     x.push(1);
     io::println(fmt!("%d", x[0]));
 }
diff --git a/src/test/run-pass/dvec-test.rs b/src/test/run-pass/dvec-test.rs
index 55a8331b8b1..06b48565785 100644
--- a/src/test/run-pass/dvec-test.rs
+++ b/src/test/run-pass/dvec-test.rs
@@ -1,7 +1,7 @@
-import dvec::dvec;
+import dvec::DVec;
 
 fn main() {
-    let d = dvec();
+    let d = DVec();
     d.push(3);
     d.push(4);
     assert d.get() == ~[3, 4];
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 825e27c86ae..f1450a5c02d 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -15,8 +15,7 @@ import std::map;
 import std::map::hashmap;
 import task;
 import comm::Chan;
-import comm::chan;
-import comm::port;
+import comm::Port;
 import comm::send;
 import comm::recv;
 import comm;
@@ -49,9 +48,9 @@ mod map_reduce {
             match im.find(key) {
               Some(_c) => { c = _c }
               None => {
-                let p = port();
+                let p = Port();
                 error!("sending find_reducer");
-                send(ctrl, find_reducer(str::to_bytes(key), chan(p)));
+                send(ctrl, find_reducer(str::to_bytes(key), Chan(p)));
                 error!("receiving");
                 c = recv(p);
                 log(error, c);
@@ -65,7 +64,7 @@ mod map_reduce {
     }
 
     fn map_reduce(inputs: ~[~str]) {
-        let ctrl = port();
+        let ctrl = Port();
 
         // This task becomes the master control task. It spawns others
         // to do the rest.
@@ -74,7 +73,7 @@ mod map_reduce {
 
         reducers = map::str_hash();
 
-        start_mappers(chan(ctrl), inputs);
+        start_mappers(Chan(ctrl), inputs);
 
         let mut num_mappers = vec::len(inputs) as int;
 
diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index 4fec03ff711..4459b97ff5b 100644
--- a/src/test/run-pass/issue-507.rs
+++ b/src/test/run-pass/issue-507.rs
@@ -10,9 +10,8 @@ use std;
 import task;
 import comm;
 import comm::Chan;
-import comm::chan;
 import comm::send;
-import comm::port;
+import comm::Port;
 import comm::recv;
 
 fn grandchild(c: Chan<int>) { send(c, 42); }
@@ -22,8 +21,8 @@ fn child(c: Chan<int>) {
 }
 
 fn main() {
-    let p = comm::port();
-    let ch = chan(p);
+    let p = comm::Port();
+    let ch = Chan(p);
 
     task::spawn(|| child(ch) );
 
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index ba81a660f7f..ed50e6e5143 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -3,9 +3,7 @@ import vec;
 import task;
 import comm;
 import comm::Chan;
-import comm::chan;
 import comm::Port;
-import comm::port;
 import comm::recv;
 import comm::send;
 
@@ -18,8 +16,8 @@ fn producer(c: Chan<~[u8]>) {
 }
 
 fn packager(cb: Chan<Chan<~[u8]>>, msg: Chan<msg>) {
-    let p: Port<~[u8]> = port();
-    send(cb, chan(p));
+    let p: Port<~[u8]> = Port();
+    send(cb, Chan(p));
     loop {
         debug!("waiting for bytes");
         let data = recv(p);
@@ -39,10 +37,10 @@ fn packager(cb: Chan<Chan<~[u8]>>, msg: Chan<msg>) {
 }
 
 fn main() {
-    let p: Port<msg> = port();
-    let ch = chan(p);
-    let recv_reader: Port<Chan<~[u8]>> = port();
-    let recv_reader_chan = chan(recv_reader);
+    let p: Port<msg> = Port();
+    let ch = Chan(p);
+    let recv_reader: Port<Chan<~[u8]>> = Port();
+    let recv_reader_chan = Chan(recv_reader);
     let pack = task::spawn(|| packager(recv_reader_chan, ch) );
 
     let source_chan: Chan<~[u8]> = recv(recv_reader);
diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs
index 5a970c46ec2..9f908625a33 100644
--- a/src/test/run-pass/issue-783.rs
+++ b/src/test/run-pass/issue-783.rs
@@ -5,11 +5,11 @@ import task::*;
 fn a() {
     fn doit() {
         fn b(c: Chan<Chan<int>>) {
-            let p = port();
-            send(c, chan(p));
+            let p = Port();
+            send(c, Chan(p));
         }
-        let p = port();
-        let ch = chan(p);
+        let p = Port();
+        let ch = Chan(p);
         spawn(|| b(ch) );
         recv(p);
     }
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index 85ac1a01019..d6a72422507 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -3,9 +3,7 @@ use std;
 import task;
 import comm;
 import comm::Chan;
-import comm::chan;
 import comm::Port;
-import comm::port;
 import comm::send;
 import comm::recv;
 
@@ -16,8 +14,8 @@ fn producer(c: Chan<~[u8]>) {
 }
 
 fn main() {
-    let p: Port<~[u8]> = port();
-    let ch = chan(p);
+    let p: Port<~[u8]> = Port();
+    let ch = Chan(p);
     let prod = task::spawn(|| producer(ch) );
 
     let data: ~[u8] = recv(p);
diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 6ee5dc44c96..ebb7507789e 100644
--- a/src/test/run-pass/lazychan.rs
+++ b/src/test/run-pass/lazychan.rs
@@ -5,8 +5,8 @@ import task;
 import comm::*;
 
 fn main() {
-    let p = port();
-    let ch = chan(p);
+    let p = Port();
+    let ch = Chan(p);
     let mut y: int;
 
     task::spawn(|| child(ch) );
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index 0f8fcd0acaf..78339d8c0c6 100644
--- a/src/test/run-pass/many.rs
+++ b/src/test/run-pass/many.rs
@@ -8,8 +8,8 @@ fn sub(parent: comm::Chan<int>, id: int) {
     if id == 0 {
         comm::send(parent, 0);
     } else {
-        let p = comm::port();
-        let ch = comm::chan(p);
+        let p = comm::Port();
+        let ch = comm::Chan(p);
         let child = task::spawn(|| sub(ch, id - 1) );
         let y = comm::recv(p);
         comm::send(parent, y + 1);
@@ -17,8 +17,8 @@ fn sub(parent: comm::Chan<int>, id: int) {
 }
 
 fn main() {
-    let p = comm::port();
-    let ch = comm::chan(p);
+    let p = comm::Port();
+    let ch = comm::Chan(p);
     let child = task::spawn(|| sub(ch, 200) );
     let y = comm::recv(p);
     debug!("transmission complete");
diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs
index 2e4e077838d..3036d4c201f 100644
--- a/src/test/run-pass/morestack6.rs
+++ b/src/test/run-pass/morestack6.rs
@@ -50,7 +50,7 @@ fn main() {
         calllink09,
         calllink10
     ];
-    let rng = rand::rng();
+    let rng = rand::Rng();
     for fns.each |f| {
         let sz = rng.next() % 256u32 + 256u32;
         let frame_backoff = rng.next() % 10u32 + 1u32;
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index e7db39c2edf..aaaa34453e0 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -6,8 +6,8 @@ use std;
 import option;
 import uint;
 import comm;
-import comm::port;
-import comm::chan;
+import comm::Port;
+import comm::Chan;
 import comm::send;
 import comm::recv;
 
@@ -20,8 +20,8 @@ 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();
-    let mychan = chan(myport);
+    let myport = Port();
+    let mychan = Chan(myport);
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
     send(mychan, val);
 }
@@ -30,8 +30,8 @@ fn test_init() {
 // Dump lots of items into the channel so it has to grow.
 // Don't trigger any assertions.
 fn test_grow() {
-    let myport = port();
-    let mychan = chan(myport);
+    let myport = Port();
+    let mychan = Chan(myport);
     for uint::range(0u, 100u) |i| {
         let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
         comm::send(mychan, val);
@@ -41,15 +41,15 @@ fn test_grow() {
 
 // Don't allow the buffer to shrink below it's original size
 fn test_shrink1() {
-    let myport = port();
-    let mychan = chan(myport);
+    let myport = Port();
+    let mychan = Chan(myport);
     send(mychan, 0i8);
     let x = recv(myport);
 }
 
 fn test_shrink2() {
-    let myport = port();
-    let mychan = chan(myport);
+    let myport = Port();
+    let mychan = Chan(myport);
     for uint::range(0u, 100u) |_i| {
         let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
         send(mychan, val);
@@ -60,8 +60,8 @@ fn test_shrink2() {
 
 // Test rotating the buffer when the unit size is not a power of two
 fn test_rotate() {
-    let myport = port();
-    let mychan = chan(myport);
+    let myport = Port();
+    let mychan = Chan(myport);
     for uint::range(0u, 100u) |i| {
         let val = {val1: i as u32, val2: i as u32, val3: i as u32};
         send(mychan, val);
@@ -76,8 +76,8 @@ 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>();
-    let mychan = chan(myport);
+    let myport = Port::<record>();
+    let mychan = Chan(myport);
     for uint::range(0u, 10u) |j| {
         for uint::range(0u, 10u) |i| {
             let val: record =
diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs
index fe6ba4b08f4..628b8d7d929 100644
--- a/src/test/run-pass/rt-sched-1.rs
+++ b/src/test/run-pass/rt-sched-1.rs
@@ -16,8 +16,8 @@ extern mod rustrt {
 }
 
 fn main() unsafe {
-    let po = comm::port();
-    let ch = comm::chan(po);
+    let po = comm::Port();
+    let ch = comm::Chan(po);
     let parent_sched_id = rustrt::rust_get_sched_id();
     error!("parent %?", parent_sched_id);
     let num_threads = 1u;
diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs
index d0a1c5c9817..6f423291cb4 100644
--- a/src/test/run-pass/send-iloop.rs
+++ b/src/test/run-pass/send-iloop.rs
@@ -10,8 +10,8 @@ fn die() {
 
 fn iloop() {
     task::spawn(|| die() );
-    let p = comm::port::<()>();
-    let c = comm::chan(p);
+    let p = comm::Port::<()>();
+    let c = comm::Chan(p);
     loop {
         // Sending and receiving here because these actions yield,
         // at which point our child can kill us
diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs
index bb3957e2707..ce91d22ec75 100644
--- a/src/test/run-pass/send-resource.rs
+++ b/src/test/run-pass/send-resource.rs
@@ -8,12 +8,12 @@ struct test {
 }
 
 fn main() {
-    let p = port();
-    let c = chan(p);
+    let p = Port();
+    let c = Chan(p);
 
     do spawn() {
-        let p = port();
-        c.send(chan(p));
+        let p = Port();
+        c.send(Chan(p));
 
         let _r = p.recv();
     }
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index a5e9867943f..cf975c54133 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/src/test/run-pass/send-type-inference.rs
@@ -1,14 +1,13 @@
 use std;
 import comm::Chan;
-import comm::chan;
 import comm::send;
-import comm::port;
+import comm::Port;
 
 // tests that ctrl's type gets inferred properly
 type command<K: send, V: send> = {key: K, val: V};
 
 fn cache_server<K: send, V: send>(c: Chan<Chan<command<K, V>>>) {
-    let ctrl = port();
-    send(c, chan(ctrl));
+    let ctrl = Port();
+    send(c, Chan(ctrl));
 }
 fn main() { }
diff --git a/src/test/run-pass/sendable-class.rs b/src/test/run-pass/sendable-class.rs
index 9d26e3d26d8..762d510da20 100644
--- a/src/test/run-pass/sendable-class.rs
+++ b/src/test/run-pass/sendable-class.rs
@@ -7,7 +7,7 @@ struct foo {
 }
 
 fn main() {
-  let po = comm::port::<foo>();
-  let ch = comm::chan(po);
+  let po = comm::Port::<foo>();
+  let ch = comm::Chan(po);
   comm::send(ch, foo(42, 'c'));
 }
\ No newline at end of file
diff --git a/src/test/run-pass/sendfn-deep-copy.rs b/src/test/run-pass/sendfn-deep-copy.rs
index 94c63a283e4..f9eaae7a354 100644
--- a/src/test/run-pass/sendfn-deep-copy.rs
+++ b/src/test/run-pass/sendfn-deep-copy.rs
@@ -1,6 +1,6 @@
 use std;
 
-import comm::chan;
+import comm::Chan;
 import comm::send;
 
 fn main() { test05(); }
diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs
index df3b476358b..486a6e0eacf 100644
--- a/src/test/run-pass/sendfn-generic-fn.rs
+++ b/src/test/run-pass/sendfn-generic-fn.rs
@@ -1,6 +1,6 @@
 use std;
 
-import comm::chan;
+import comm::Chan;
 import comm::send;
 
 fn main() { test05(); }
diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index 6272b20163c..3e268e6a4a9 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -1,6 +1,6 @@
 use std;
 
-import comm::chan;
+import comm::Chan;
 import comm::send;
 
 fn main() { test05(); }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index 0c2dda20035..7151da4563a 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -17,7 +17,7 @@ fn iotask(cx: ctx, ip: ~str) {
 }
 
 fn main() {
-    let p = comm::port::<int>();
-    let ch = comm::chan(p);
+    let p = comm::Port::<int>();
+    let ch = comm::Chan(p);
     task::spawn(|| iotask(ch, ~"localhost") );
 }
diff --git a/src/test/run-pass/task-comm-chan-cleanup.rs b/src/test/run-pass/task-comm-chan-cleanup.rs
index 39c3eefd774..26506dc4bc8 100644
--- a/src/test/run-pass/task-comm-chan-cleanup.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup.rs
@@ -2,7 +2,7 @@ use std;
 import comm;
 
 fn main() {
-    let p = comm::port();
-    let c = comm::chan(p);
+    let p = comm::Port();
+    let c = comm::Chan(p);
     comm::send(c, ~"coffee");
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-chan-cleanup2.rs b/src/test/run-pass/task-comm-chan-cleanup2.rs
index 39c3eefd774..26506dc4bc8 100644
--- a/src/test/run-pass/task-comm-chan-cleanup2.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup2.rs
@@ -2,7 +2,7 @@ use std;
 import comm;
 
 fn main() {
-    let p = comm::port();
-    let c = comm::chan(p);
+    let p = comm::Port();
+    let c = comm::Chan(p);
     comm::send(c, ~"coffee");
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-chan-cleanup3.rs b/src/test/run-pass/task-comm-chan-cleanup3.rs
index a153d4a8e5d..f01282f0f6c 100644
--- a/src/test/run-pass/task-comm-chan-cleanup3.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup3.rs
@@ -3,8 +3,8 @@ import comm;
 
 fn main() {
     let c = {
-        let p = comm::port();
-        comm::chan(p)
+        let p = comm::Port();
+        comm::Chan(p)
     };
     comm::send(c, ~"coffee");
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-chan-cleanup4.rs b/src/test/run-pass/task-comm-chan-cleanup4.rs
index 65762cae08c..b839a9ae30f 100644
--- a/src/test/run-pass/task-comm-chan-cleanup4.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup4.rs
@@ -14,8 +14,8 @@ fn starship(&&ch: comm::Chan<~str>) {
 
 fn starbase() {
     for int::range(0, 10) |_i| {
-        let p = comm::port();
-        let c = comm::chan(p);
+        let p = comm::Port();
+        let c = comm::Chan(p);
         task::spawn(|| starship(c) );
         task::yield();
     }
diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs
index 785ab6979e2..25b64bc074e 100644
--- a/src/test/run-pass/task-comm-chan-nil.rs
+++ b/src/test/run-pass/task-comm-chan-nil.rs
@@ -7,8 +7,8 @@ import comm;
 // 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 = comm::port();
-    let ch = comm::chan(po);
+    let po = comm::Port();
+    let ch = comm::Chan(po);
     comm::send(ch, ());
     let n: () = comm::recv(po);
     assert (n == ());
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 6baca1681d7..6be6729b7c2 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -4,8 +4,7 @@ import task;
 import task::task;
 import comm;
 import comm::Chan;
-import comm::chan;
-import comm::port;
+import comm::Port;
 import comm::send;
 import comm::recv;
 
@@ -34,8 +33,8 @@ fn test00() {
     let number_of_messages: int = 4;
     debug!("Creating tasks");
 
-    let po = port();
-    let ch = chan(po);
+    let po = Port();
+    let ch = Chan(po);
 
     let mut i: int = 0;
 
@@ -64,15 +63,15 @@ fn test00() {
 }
 
 fn test01() {
-    let p = port();
+    let p = Port();
     debug!("Reading from a port that is never written to.");
     let value: int = recv(p);
     log(debug, value);
 }
 
 fn test02() {
-    let p = port();
-    let c = chan(p);
+    let p = Port();
+    let c = Chan(p);
     debug!("Writing to a local task channel.");
     send(c, 42);
     debug!("Reading from a local task port.");
@@ -103,8 +102,8 @@ fn test05_start(ch: Chan<int>) {
 }
 
 fn test05() {
-    let po = comm::port();
-    let ch = chan(po);
+    let po = comm::Port();
+    let ch = Chan(po);
     task::spawn(|| test05_start(ch) );
     let mut value: int;
     value = recv(po);
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index 221af971e0d..ce631196fbe 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -30,8 +30,8 @@ fn joinable(+f: fn~()) -> comm::Port<bool> {
         f();
         *b = true;
     }
-    let p = comm::port();
-    let c = comm::chan(p);
+    let p = comm::Port();
+    let c = comm::Chan(p);
     do task::spawn_unlinked { wrapper(c, copy f) };
     p
 }
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index cf98be6effb..9cedfea6130 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -1,6 +1,6 @@
 fn main() {
-    let p = comm::port::<uint>();
-    let ch = comm::chan(p);
+    let p = comm::Port::<uint>();
+    let ch = comm::Chan(p);
 
     let x = ~1;
     let x_in_parent = ptr::addr_of(*x) as uint;
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 89da4e65f88..fa98f886a5c 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -8,8 +8,8 @@ fn child(c: comm::Chan<~uint>, i: uint) {
 }
 
 fn main() {
-    let p = comm::port();
-    let ch = comm::chan(p);
+    let p = comm::Port();
+    let ch = comm::Chan(p);
     let n = 100u;
     let mut expected = 0u;
     for uint::range(0u, n) |i| {
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index 58ff64a6cc9..eabfc1e859f 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -3,8 +3,8 @@ import comm;
 import task;
 
 fn main() {
-    let p = comm::port();
-    let c = comm::chan(p);
+    let p = comm::Port();
+    let c = comm::Chan(p);
     comm::send(c, ~100);
     let v = comm::recv(p);
     assert v == ~100;
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index bbb39c601b2..c8b2be18e15 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -19,8 +19,8 @@ fn f(c: comm::Chan<bool>) {
 }
 
 fn main() {
-    let p = comm::port();
-    let c = comm::chan(p);
+    let p = comm::Port();
+    let c = comm::Chan(p);
     task::spawn_unlinked(|| f(c) );
     error!("hiiiiiiiii");
     assert comm::recv(p);