Update stdlib, compiler, and tests to new kind system

This involved adding 'copy' to more generics than I hoped, but an
experiment with making it implicit showed that that way lies madness --
unless enforced, you will not remember to mark functions that don't
copy as not requiring copyable kind.

Issue #1177

66 files changed, 116 insertions, 266 deletions

diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index af2a4e2889d..5f6c1e92309 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -55,25 +55,25 @@ mod map_reduce {
     export reducer;
     export map_reduce;
 
-    type putter<uniq K, uniq V> = fn(K, V);
+    type putter<send K, send V> = fn(K, V);
 
     // FIXME: the first K1 parameter should probably be a -, but that
     // doesn't parse at the moment.
-    type mapper<uniq K1, uniq K2, uniq V> = fn(K1, putter<K2, V>);
+    type mapper<send K1, send K2, send V> = fn(K1, putter<K2, V>);
 
-    type getter<uniq V> = fn() -> option<V>;
+    type getter<send V> = fn() -> option<V>;
 
-    type reducer<uniq K, uniq V> = fn(K, getter<V>);
+    type reducer<send K, send V> = fn(K, getter<V>);
 
-    tag ctrl_proto<uniq K, uniq V> {
+    tag ctrl_proto<send K, send V> {
         find_reducer(K, chan<chan<reduce_proto<V>>>);
         mapper_done;
     }
 
-    tag reduce_proto<uniq V> { emit_val(V); done; ref; release; }
+    tag reduce_proto<send V> { emit_val(V); done; ref; release; }
 
-    fn start_mappers<uniq K1, uniq K2,
-                     uniq V>(map: mapper<K1, K2, V>,
+    fn start_mappers<send K1, send K2,
+                     send V>(map: mapper<K1, K2, V>,
                          ctrl: chan<ctrl_proto<K2, V>>, inputs: [K1]) ->
        [joinable_task] {
         let tasks = [];
@@ -84,15 +84,15 @@ mod map_reduce {
         ret tasks;
     }
 
-    fn map_task<uniq K1, uniq K2,
-                uniq V>(-map: mapper<K1, K2, V>,
+    fn map_task<send K1, send K2,
+                send V>(-map: mapper<K1, K2, V>,
                           -ctrl: chan<ctrl_proto<K2, V>>,
                     -input: K1) {
         // log_err "map_task " + input;
         let intermediates = treemap::init();
 
-        fn emit<uniq K2,
-                uniq V>(im: treemap::treemap<K2, chan<reduce_proto<V>>>,
+        fn emit<send K2,
+                send V>(im: treemap::treemap<K2, chan<reduce_proto<V>>>,
                     ctrl: chan<ctrl_proto<K2, V>>, key: K2, val: V) {
             let c;
             alt treemap::find(im, key) {
@@ -110,15 +110,15 @@ mod map_reduce {
 
         map(input, bind emit(intermediates, ctrl, _, _));
 
-        fn finish<uniq K, uniq V>(_k: K, v: chan<reduce_proto<V>>) {
+        fn finish<send K, send V>(_k: K, v: chan<reduce_proto<V>>) {
             send(v, release);
         }
         treemap::traverse(intermediates, finish);
         send(ctrl, mapper_done);
     }
 
-    fn reduce_task<uniq K,
-                   uniq V>(-reduce: reducer<K, V>, -key: K,
+    fn reduce_task<send K,
+                   send V>(-reduce: reducer<K, V>, -key: K,
                        -out: chan<chan<reduce_proto<V>>>) {
         let p = port();
 
@@ -127,7 +127,7 @@ mod map_reduce {
         let ref_count = 0;
         let is_done = false;
 
-        fn get<uniq V>(p: port<reduce_proto<V>>,
+        fn get<send V>(p: port<reduce_proto<V>>,
                          &ref_count: int, &is_done: bool)
            -> option<V> {
             while !is_done || ref_count > 0 {
@@ -150,8 +150,8 @@ mod map_reduce {
         reduce(key, bind get(p, ref_count, is_done));
     }
 
-    fn map_reduce<uniq K1, uniq K2,
-                  uniq V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>,
+    fn map_reduce<send K1, send K2,
+                  send V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>,
                       inputs: [K1]) {
         let ctrl = port();
 
@@ -194,7 +194,7 @@ mod map_reduce {
             }
         }
 
-        fn finish<uniq K, uniq V>(_k: K, v: chan<reduce_proto<V>>) {
+        fn finish<send K, send V>(_k: K, v: chan<reduce_proto<V>>) {
             send(v, done);
         }
         treemap::traverse(reducers, finish);
diff --git a/src/test/compile-fail/block-copy.rs b/src/test/compile-fail/block-copy.rs
index 12bc0a0b2b9..b14bb3ddedd 100644
--- a/src/test/compile-fail/block-copy.rs
+++ b/src/test/compile-fail/block-copy.rs
@@ -1,5 +1,4 @@
-// error-pattern: needed shared type, got pinned type block
-// xfail-test
+// error-pattern: copying a noncopyable value
 
 fn lol(f: block()) -> block() { ret f; }
 fn main() { let i = 8; let f = lol(block () { log_err i; }); f(); }
diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs
index f9e38941aa6..46807e05252 100644
--- a/src/test/compile-fail/copy-a-resource.rs
+++ b/src/test/compile-fail/copy-a-resource.rs
@@ -1,6 +1,5 @@
-// error-pattern:cannot copy pinned type foo
-// xfail-test
+// error-pattern: copying a noncopyable value
 
 resource foo(i: int) { }
 
-fn main() { let x <- foo(10); let y = x; }
+fn main() { let x <- foo(10); let y = x; log_err x; }
diff --git a/src/test/compile-fail/copy-res-into-box.rs b/src/test/compile-fail/copy-res-into-box.rs
deleted file mode 100644
index b4038b61d3e..00000000000
--- a/src/test/compile-fail/copy-res-into-box.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// error-pattern:mismatched kinds for '@' operand
-// xfail-test
-resource r(i: @mutable int) {
-    *i = *i + 1;
-}
-
-fn main() {
-    let i = @mutable 0;
-    {
-        let j <- r(i);
-        // No no no no no
-        let k <- @j;
-    }
-    log_err *i;
-    assert *i == 2;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/copy-res-into-rec.rs b/src/test/compile-fail/copy-res-into-rec.rs
deleted file mode 100644
index 0fec1ba8a04..00000000000
--- a/src/test/compile-fail/copy-res-into-rec.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// error-pattern:mismatched kinds for record field
-// xfail-test
-resource r(i: @mutable int) {
-    *i = *i + 1;
-}
-
-fn main() {
-    let i = @mutable 0;
-    {
-        let j <- r(i);
-        // No no no no no
-        let k <- {x: j};
-    }
-    log_err *i;
-    assert *i == 2;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/copy-res-into-tup.rs b/src/test/compile-fail/copy-res-into-tup.rs
deleted file mode 100644
index e9318ae4280..00000000000
--- a/src/test/compile-fail/copy-res-into-tup.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// error-pattern:mismatched kinds for tuple parameter
-// xfail-test
-resource r(i: @mutable int) {
-    *i = *i + 1;
-}
-
-fn main() {
-    let i = @mutable 0;
-    {
-        let j <- r(i);
-        // No no no no no
-        let k <- (j, 0);
-    }
-    log_err *i;
-    assert *i == 2;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/copy-res-into-unique.rs b/src/test/compile-fail/copy-res-into-unique.rs
deleted file mode 100644
index 6fa1e852b4a..00000000000
--- a/src/test/compile-fail/copy-res-into-unique.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// error-pattern:mismatched kinds for '~' operand
-// xfail-test
-resource r(i: @mutable int) {
-    *i = *i + 1;
-}
-
-fn main() {
-    let i = @mutable 0;
-    {
-        let j <- r(i);
-        // No no no no no
-        let k <- ~j;
-    }
-    log_err *i;
-    assert *i == 2;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/fn-compare-mismatch.rs b/src/test/compile-fail/fn-compare-mismatch.rs
index b844e7308b6..56238a6026f 100644
--- a/src/test/compile-fail/fn-compare-mismatch.rs
+++ b/src/test/compile-fail/fn-compare-mismatch.rs
@@ -1,4 +1,4 @@
-// error-pattern:expected fn() but found fn(+int)
+// error-pattern:expected fn() but found fn(++int)
 
 fn main() {
     fn f() { }
diff --git a/src/test/compile-fail/param-by-value.rs b/src/test/compile-fail/param-by-value.rs
index 5e8321cb11f..2587e35219c 100644
--- a/src/test/compile-fail/param-by-value.rs
+++ b/src/test/compile-fail/param-by-value.rs
@@ -1,4 +1,4 @@
 // error-pattern:can not pass a dynamically-sized type by value
 
-fn f<T>(+_x: T) {}
+fn f<T>(++_x: T) {}
 fn main() {}
diff --git a/src/test/compile-fail/pinned-deep-copy.rs b/src/test/compile-fail/pinned-deep-copy.rs
index 9e8081ca6ce..3d6c6f0c6eb 100644
--- a/src/test/compile-fail/pinned-deep-copy.rs
+++ b/src/test/compile-fail/pinned-deep-copy.rs
@@ -1,5 +1,4 @@
-// error-pattern: cannot copy pinned type ~~~{y: r}
-// xfail-test
+// error-pattern: copying a noncopyable value
 
 resource r(i: @mutable int) {
     *i = *i + 1;
@@ -11,6 +10,7 @@ fn main() {
         // Can't do this copy
         let x = ~~~{y: r(i)};
         let z = x;
+        log x;
     }
     log_err *i;
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/resource-let2.rs b/src/test/compile-fail/resource-let2.rs
deleted file mode 100644
index 17855a30bd0..00000000000
--- a/src/test/compile-fail/resource-let2.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// error-pattern: mismatched kind
-// xfail-test
-
-resource r(b: bool) {
-}
-
-fn main() {
-    let i <- r(true);
-    let j = i;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs
index 612dd0dda03..6bde4cbc6a4 100644
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -1,11 +1,10 @@
-// error-pattern: mismatched kind
-// xfail-test
+// error-pattern: copying a noncopyable value
 
 resource r(b: bool) {
 }
 
 fn main() {
     let i <- ~r(true);
-    let j;
-    j = i;
+    let j = i;
+    log i;
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/unique-swap2.rs b/src/test/compile-fail/unique-swap2.rs
deleted file mode 100644
index 2a653010701..00000000000
--- a/src/test/compile-fail/unique-swap2.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-// error-pattern:needed shared type, got pinned type ~r
-// xfail-test
-
-resource r(i: @mutable int) {
-    *i += 1;
-}
-
-fn test1() {
-    let i = @mutable 100;
-    let j = @mutable 200;
-    {
-        let x <- ~r(i);
-        let y <- ~r(j);
-        // This is currently not allowed because ~resource is pinned.
-        // Note that ~resource is supposed to be shared.
-        x <-> y;
-        assert ***x == 200;
-        assert ***y == 100;
-    }
-    assert *i == 101;
-    assert *j == 201;
-}
-
-fn test2() {
-    let i = @mutable 0;
-    {
-        let x <- ~r(i);
-        let y <- ~r(i);
-        x <-> y;
-    }
-    assert *i == 2;
-}
-
-fn main() {
-    test1();
-    test2();
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs
index b20c552a011..ad172f7ae83 100644
--- a/src/test/compile-fail/unique-unique-kind.rs
+++ b/src/test/compile-fail/unique-unique-kind.rs
@@ -1,7 +1,6 @@
-// error-pattern: needed unique type
-// xfail-test
+// error-pattern: instantiating a sendable type parameter with a copyable type
 
-fn f<uniq T>(i: T) {
+fn f<send T>(i: T) {
 }
 
 fn main() {
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index 434b18bbb06..0b16c513350 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -1,12 +1,10 @@
-// error-pattern: needed shared type, got pinned type ~r
-// xfail-test
+// error-pattern: copying a noncopyable value
 
 resource r(i: @mutable int) {
     *i = *i + 1;
 }
 
-fn f<T>(i: [T], j: [T]) {
-    // Shouldn't be able to do this copy of j
+fn f<T>(+i: [T], +j: [T]) {
     let k = i + j;
 }
 
@@ -16,6 +14,6 @@ fn main() {
     let r1 <- [~r(i1)];
     let r2 <- [~r(i2)];
     f(r1, r2);
-    log_err *i1;
-    log_err *i2;
+    log (r2, *i1);
+    log (r1, *i2);
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs
index 7a70292f526..e625ef138d4 100644
--- a/src/test/compile-fail/use-after-send.rs
+++ b/src/test/compile-fail/use-after-send.rs
@@ -1,5 +1,5 @@
 // error-pattern: Unsatisfied precondition constraint
-fn send<uniq T>(ch: _chan<T>, -data: T) { log ch; log data; fail; }
+fn send<send T>(ch: _chan<T>, -data: T) { log ch; log data; fail; }
 type _chan<T> = int;
 
 // Tests that "log message;" is flagged as using
diff --git a/src/test/compile-fail/vec-pinned-nocopy-2.rs b/src/test/compile-fail/vec-pinned-nocopy-2.rs
deleted file mode 100644
index 168429b6c8f..00000000000
--- a/src/test/compile-fail/vec-pinned-nocopy-2.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// error-pattern: mismatched kind
-// xfail-test
-
-resource r(b: bool) {
-}
-
-fn main() {
-    let i <- [r(true)];
-    i += [r(true)];
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/vec-pinned-nocopy-3.rs b/src/test/compile-fail/vec-pinned-nocopy-3.rs
deleted file mode 100644
index 54493ea4536..00000000000
--- a/src/test/compile-fail/vec-pinned-nocopy-3.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// error-pattern: mismatched kind
-// xfail-test
-
-resource r(b: bool) {
-}
-
-fn main() {
-    let i <- [r(true)];
-    let j;
-    j <- copy [r(true)];
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/vec-pinned-nocopy.rs b/src/test/compile-fail/vec-pinned-nocopy.rs
deleted file mode 100644
index 91dfb4fd6f0..00000000000
--- a/src/test/compile-fail/vec-pinned-nocopy.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// error-pattern: mismatched kind
-// xfail-test
-
-resource r(b: bool) {
-}
-
-fn main() {
-    let i <- [r(true)];
-    let j;
-    j = i;
-}
\ No newline at end of file
diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs
index 3d240a76480..818080a6e55 100644
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -1,12 +1,11 @@
-// error-pattern:mismatched kinds
-// xfail-test
+// error-pattern: copying a noncopyable value
 
-resource r(i: int) {
-}
+resource r(_i: int) { }
 
 fn main() {
     // This can't make sense as it would copy the resources
     let i <- [r(0)];
     let j <- [r(1)];
     let k = i + j;
-}
\ No newline at end of file
+    log j;
+}
diff --git a/src/test/run-fail/bug-811.rs b/src/test/run-fail/bug-811.rs
index 95041c72ca8..a257a903fd2 100644
--- a/src/test/run-fail/bug-811.rs
+++ b/src/test/run-fail/bug-811.rs
@@ -4,8 +4,8 @@ fn test00_start(ch: chan_t<int>, message: int) { send(ch, copy message); }
 type task_id = int;
 type port_id = int;
 
-type chan_t<uniq T> = {task: task_id, port: port_id};
+type chan_t<send T> = {task: task_id, port: port_id};
 
-fn send<uniq T>(ch: chan_t<T>, -data: T) { fail; }
+fn send<send T>(ch: chan_t<T>, -data: T) { fail; }
 
 fn main() { fail "quux"; }
diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs
index e9a4e0679b7..e227b3d4c93 100644
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -5,7 +5,7 @@ import std::comm::port;
 import std::comm::send;
 import std::comm::recv;
 
-fn echo<uniq T>(c: chan<T>, oc: chan<chan<T>>) {
+fn echo<send T>(c: chan<T>, oc: chan<chan<T>>) {
     // Tests that the type argument in port gets
     // visited
     let p = port::<T>();
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index 4900df4aed0..e701427a8a3 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -2,6 +2,6 @@
 
 
 // -*- rust -*-
-fn f<T, U>(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; }
+fn f<copy T, copy U>(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; }
 
 fn main() { log f({x: 3, y: 4, z: 5}, 4).a.x; log f(5, 6).a; }
diff --git a/src/test/run-pass/bind-generic.rs b/src/test/run-pass/bind-generic.rs
index 888c5021b3f..882a54f603b 100644
--- a/src/test/run-pass/bind-generic.rs
+++ b/src/test/run-pass/bind-generic.rs
@@ -1,4 +1,4 @@
-fn wrapper3<T>(i: T, j: int) {
+fn wrapper3<copy T>(i: T, j: int) {
     log i;
     log j;
     // This is a regression test that the spawn3 thunk to wrapper3
@@ -6,7 +6,7 @@ fn wrapper3<T>(i: T, j: int) {
     assert j == 123456789;
 }
 
-fn spawn3<T>(i: T, j: int) {
+fn spawn3<copy T>(i: T, j: int) {
     let wrapped = bind wrapper3(i, j);
     wrapped();
 }
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index 5dc0c670dca..56bcbb717ad 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -1,8 +1,8 @@
 
 
-type box<T> = {c: @T};
+type box<copy T> = {c: @T};
 
-fn unbox<T>(b: box<T>) -> T { ret *b.c; }
+fn unbox<copy T>(b: box<T>) -> T { ret *b.c; }
 
 fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs
index 9a54cd20a8b..ba98b8546a1 100644
--- a/src/test/run-pass/expr-block-generic-box2.rs
+++ b/src/test/run-pass/expr-block-generic-box2.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 type compare<T> = fn@(T, T) -> bool;
 
-fn test_generic<T>(expected: T, eq: compare<T>) {
+fn test_generic<copy T>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index 1055cd16221..436689f68aa 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -3,7 +3,7 @@
 // -*- rust -*-
 type compare<T> = fn@(~T, ~T) -> bool;
 
-fn test_generic<T>(expected: ~T, eq: compare<T>) {
+fn test_generic<copy T>(expected: ~T, eq: compare<T>) {
     let actual: ~T = { expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs
index 3325c8f2384..fba64608186 100644
--- a/src/test/run-pass/expr-block-generic-unique2.rs
+++ b/src/test/run-pass/expr-block-generic-unique2.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 type compare<T> = fn@(T, T) -> bool;
 
-fn test_generic<T>(expected: T, eq: compare<T>) {
+fn test_generic<copy T>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs
index 8e270a56edd..4424d144e15 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -6,7 +6,7 @@
 // Tests for standalone blocks as expressions with dynamic type sizes
 type compare<T> = fn@(T, T) -> bool;
 
-fn test_generic<T>(expected: T, eq: compare<T>) {
+fn test_generic<copy T>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs
index 549d3a69aea..da00556eb4e 100644
--- a/src/test/run-pass/expr-if-generic-box2.rs
+++ b/src/test/run-pass/expr-if-generic-box2.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 type compare<T> = fn@(T, T) -> bool;
 
-fn test_generic<T>(expected: T, not_expected: T, eq: compare<T>) {
+fn test_generic<copy T>(expected: T, not_expected: T, eq: compare<T>) {
     let actual: T = if true { expected } else { not_expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs
index b2b62523e55..f98a8742cc2 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -6,7 +6,7 @@
 // Tests for if as expressions with dynamic type sizes
 type compare<T> = fn@(T, T) -> bool;
 
-fn test_generic<T>(expected: T, not_expected: T, eq: compare<T>) {
+fn test_generic<copy T>(expected: T, not_expected: T, eq: compare<T>) {
     let actual: T = if true { expected } else { not_expected };
     assert (eq(expected, actual));
 }
diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs
index 6fe82172814..bbfc3f53f26 100644
--- a/src/test/run-pass/fixed-point-bind-unique.rs
+++ b/src/test/run-pass/fixed-point-bind-unique.rs
@@ -1,8 +1,8 @@
-fn fix_help<A, uniq B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B {
+fn fix_help<A, send B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B {
     ret f(bind fix_help(f, _), x);
 }
 
-fn fix<A, uniq B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B {
+fn fix<A, send B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B {
     ret bind fix_help(f, _);
 }
 
diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs
index e0da008d75c..59a57b8597c 100644
--- a/src/test/run-pass/fn-bare-spawn.rs
+++ b/src/test/run-pass/fn-bare-spawn.rs
@@ -1,6 +1,6 @@
 // This is what the signature to spawn should look like with bare functions
 
-fn spawn<uniq T>(val: T, f: fn(T)) {
+fn spawn<send T>(val: T, f: fn(T)) {
     f(val);
 }
 
diff --git a/src/test/run-pass/foreach-unique-drop.rs b/src/test/run-pass/foreach-unique-drop.rs
index 6778f2597ed..5b696a0efe9 100644
--- a/src/test/run-pass/foreach-unique-drop.rs
+++ b/src/test/run-pass/foreach-unique-drop.rs
@@ -1,5 +1,5 @@
 
-obj ob<shar K>(k: K) {
+obj ob<copy K>(k: K) {
     fn foo(it: block(~{a: K})) { it(~{a: k}); }
 }
 
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 9624eca31ac..470815996ce 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: T) -> T { ret t; }
+fn id<copy T>(t: T) -> T { ret t; }
 
 fn main() {
     let expected = @100;
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index d1b7598d35e..1ca044ef162 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -1,6 +1,6 @@
 
 
-fn id<uniq T>(t: T) -> T { ret t; }
+fn id<send T>(t: T) -> T { ret t; }
 
 fn main() {
     let expected = ~100;
diff --git a/src/test/run-pass/generic-bind-2.rs b/src/test/run-pass/generic-bind-2.rs
index 8b03cc68f0f..c633cb2d08a 100644
--- a/src/test/run-pass/generic-bind-2.rs
+++ b/src/test/run-pass/generic-bind-2.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: T) -> T { ret t; }
+fn id<copy T>(t: T) -> T { ret t; }
 
 fn main() {
     let t = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7};
diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs
index 47e0ffc973e..8464bfb0241 100644
--- a/src/test/run-pass/generic-bind.rs
+++ b/src/test/run-pass/generic-bind.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: T) -> T { ret t; }
+fn id<copy T>(t: T) -> T { ret t; }
 
 fn main() {
     let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7};
diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs
index 3e37834f47b..87465ae6a93 100644
--- a/src/test/run-pass/generic-box.rs
+++ b/src/test/run-pass/generic-box.rs
@@ -1,6 +1,6 @@
 
 
-fn box<T>(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; }
+fn box<copy T>(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; }
 
 fn main() {
     let x: @{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3});
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index 50834dd2b1f..05f311167cf 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -1,8 +1,8 @@
 
 
-fn g<X>(x: X) -> X { ret x; }
+fn g<copy X>(x: X) -> X { ret x; }
 
-fn f<T>(t: T) -> {a: T, b: T} {
+fn f<copy T>(t: T) -> {a: T, b: T} {
     type pair = {a: T, b: T};
 
     let x: pair = {a: t, b: t};
diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs
index ad89b7fe556..ced0ecfbe9e 100644
--- a/src/test/run-pass/generic-drop-glue.rs
+++ b/src/test/run-pass/generic-drop-glue.rs
@@ -1,5 +1,5 @@
 
 
-fn f<T>(t: T) { let t1: T = t; }
+fn f<copy T>(t: T) { let t1: T = t; }
 
 fn main() { let x = {x: @10, y: @12}; f(x); }
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
index 7573bff74e8..41315e15643 100644
--- a/src/test/run-pass/generic-exterior-box.rs
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -1,8 +1,8 @@
 
 
-type recbox<T> = {x: @T};
+type recbox<copy T> = {x: @T};
 
-fn reclift<T>(t: T) -> recbox<T> { ret {x: @t}; }
+fn reclift<copy T>(t: T) -> recbox<T> { ret {x: @t}; }
 
 fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index 09c2a5daead..1a97c134748 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -1,6 +1,6 @@
-type recbox<T> = {x: ~T};
+type recbox<copy T> = {x: ~T};
 
-fn reclift<T>(t: T) -> recbox<T> { ret {x: ~t}; }
+fn reclift<copy T>(t: T) -> recbox<T> { ret {x: ~t}; }
 
 fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
index d45722ccc94..57d4052e5a0 100644
--- a/src/test/run-pass/generic-fn-infer.rs
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -4,6 +4,6 @@
 // -*- rust -*-
 
 // Issue #45: infer type parameters in function applications
-fn id<T>(x: T) -> T { ret x; }
+fn id<copy T>(x: T) -> T { ret x; }
 
 fn main() { let x: int = 42; let y: int = id(x); assert (x == y); }
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index 28f3fcec1e4..49cc7600315 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -1,4 +1,4 @@
 
-fn f<T>(x: ~T) -> ~T { ret x; }
+fn f<copy T>(x: ~T) -> ~T { ret x; }
 
 fn main() { let x = f(~3); log *x; }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index 9dbd6dd156c..63350c44273 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-fn id<T>(x: T) -> T { ret x; }
+fn id<copy T>(x: T) -> T { ret x; }
 
 type triple = {x: int, y: int, z: int};
 
diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs
index 435a61e165f..5aa6769da64 100644
--- a/src/test/run-pass/generic-obj-with-derived-type.rs
+++ b/src/test/run-pass/generic-obj-with-derived-type.rs
@@ -1,6 +1,6 @@
 
 
-obj handle<shar T>(data: T) {
+obj handle<copy T>(data: T) {
     fn get() -> T { ret data; }
 }
 
diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs
index eb3d7793e8b..fa90e5863b6 100644
--- a/src/test/run-pass/generic-obj.rs
+++ b/src/test/run-pass/generic-obj.rs
@@ -1,6 +1,6 @@
 
 
-obj buf<shar T>(data: {_0: T, _1: T, _2: T}) {
+obj buf<copy T>(data: {_0: T, _1: T, _2: T}) {
     fn get(i: int) -> T {
         if i == 0 {
             ret data._0;
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index e85de5dd485..7134c96d4e2 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -1,4 +1,4 @@
-fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; }
+fn get_third<copy T>(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; }
 
 fn main() {
     log get_third((1, 2, 3));
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 29a40dd4c1f..3b6b19ce450 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -1,5 +1,5 @@
 
-fn box<T>(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; }
+fn box<copy T>(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; }
 
 fn main() {
     let x: ~{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3});
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index 0a01845841a..793df760b4b 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -1,5 +1,5 @@
-fn quux<T>(x: T) -> T { let f = bind id::<T>(_); ret f(x); }
+fn quux<copy T>(x: T) -> T { let f = bind id::<T>(_); ret f(x); }
 
-fn id<T>(x: T) -> T { ret x; }
+fn id<copy T>(x: T) -> T { ret x; }
 
 fn main() { assert (quux(10) == 10); }
diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs
index f9378b21317..9e45b028386 100644
--- a/src/test/run-pass/ivec-add.rs
+++ b/src/test/run-pass/ivec-add.rs
@@ -1,4 +1,4 @@
-fn double<T>(a: T) -> [T] { ret [a] + [a]; }
+fn double<copy T>(a: T) -> [T] { ret [a] + [a]; }
 
 fn double_int(a: int) -> [int] { ret [a] + [a]; }
 
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index e08ace6947d..5bb2171dfd2 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -1,8 +1,8 @@
 tag myvec<X> = [X];
 
-fn myvec_deref<X>(mv: myvec<X>) -> [X] { ret *mv; }
+fn myvec_deref<copy X>(mv: myvec<X>) -> [X] { ret *mv; }
 
-fn myvec_elt<X>(mv: myvec<X>) -> X { ret mv[0]; }
+fn myvec_elt<copy X>(mv: myvec<X>) -> X { ret mv[0]; }
 
 fn main() {
     let mv = myvec([1, 2, 3]);
diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs
index 6bd044c9574..3a85cba6162 100644
--- a/src/test/run-pass/non-boolean-pure-fns.rs
+++ b/src/test/run-pass/non-boolean-pure-fns.rs
@@ -2,19 +2,19 @@ use std;
 
 import std::list::*;
 
-pure fn pure_length_go<T>(ls: list<T>, acc: uint) -> uint {
+pure fn pure_length_go<copy T>(ls: list<T>, acc: uint) -> uint {
     alt ls { nil. { acc } cons(_, tl) { pure_length_go(*tl, acc + 1u) } }
 }
 
-pure fn pure_length<T>(ls: list<T>) -> uint { pure_length_go(ls, 0u) }
+pure fn pure_length<copy T>(ls: list<T>) -> uint { pure_length_go(ls, 0u) }
 
-pure fn nonempty_list<T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
+pure fn nonempty_list<copy T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
 
 // Of course, the compiler can't take advantage of the
 // knowledge that ls is a cons node. Future work.
 // Also, this is pretty contrived since nonempty_list
 // could be a "tag refinement", if we implement those.
-fn safe_head<T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
+fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
 
 fn main() {
     let mylist = cons(@1u, @nil);
diff --git a/src/test/run-pass/obj-return-polytypes.rs b/src/test/run-pass/obj-return-polytypes.rs
index e8747f1a95b..ebfcf37e79d 100644
--- a/src/test/run-pass/obj-return-polytypes.rs
+++ b/src/test/run-pass/obj-return-polytypes.rs
@@ -6,7 +6,7 @@ tag clam<T> { signed(int); unsigned(uint); }
 
 fn getclam<T>() -> clam<T> { ret signed::<T>(42); }
 
-obj impatience<shar T>() {
+obj impatience<copy T>() {
     fn moreclam() -> clam<T> { be getclam::<T>(); }
 }
 
diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs
index 96cc02337cc..758beb3d9e1 100644
--- a/src/test/run-pass/resource-in-struct.rs
+++ b/src/test/run-pass/resource-in-struct.rs
@@ -5,7 +5,7 @@ type closable = @mutable bool;
 
 resource close_res(i: closable) { *i = false; }
 
-tag option<pin T> { none; some(T); }
+tag option<T> { none; some(T); }
 
 fn sink(res: option<close_res>) { }
 
diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs
index b56db9f9c70..fe91c15c72d 100644
--- a/src/test/run-pass/ret-none.rs
+++ b/src/test/run-pass/ret-none.rs
@@ -2,6 +2,6 @@
 
 tag option<T> { none; some(T); }
 
-fn f<T>() -> option<T> { ret none; }
+fn f<copy T>() -> option<T> { ret none; }
 
 fn main() { f::<int>(); }
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index 0cc9a45d062..aad9a0696d1 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/src/test/run-pass/send-type-inference.rs
@@ -4,9 +4,9 @@ import std::comm::send;
 import std::comm::port;
 
 // tests that ctrl's type gets inferred properly
-type command<uniq K, uniq V> = {key: K, val: V};
+type command<send K, send V> = {key: K, val: V};
 
-fn cache_server<uniq K, uniq V>(c: chan<chan<command<K, V>>>) {
+fn cache_server<send K, send V>(c: chan<chan<command<K, V>>>) {
     let ctrl = port();
     send(c, chan(ctrl));
 }
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index 445632e33b5..b6d76bc9d7c 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -1,6 +1,6 @@
-fn p_foo<pin T>(pinned: T) { }
-fn s_foo<T>(shared: T) { }
-fn u_foo<uniq T>(unique: T) { }
+fn p_foo<T>(pinned: T) { }
+fn s_foo<copy T>(shared: T) { }
+fn u_foo<send T>(unique: T) { }
 
 resource r(i: int) { }
 
diff --git a/src/test/run-pass/unchecked-predicates.rs b/src/test/run-pass/unchecked-predicates.rs
index e33c080e64f..a4c80b57549 100644
--- a/src/test/run-pass/unchecked-predicates.rs
+++ b/src/test/run-pass/unchecked-predicates.rs
@@ -5,24 +5,24 @@ import std::list::*;
 
 // Can't easily be written as a "pure fn" because there's
 // no syntax for specifying that f is pure.
-fn pure_foldl<T, U>(ls: list<T>, u: U, f: block(T, U) -> U) -> U {
+fn pure_foldl<copy T, copy U>(ls: list<T>, u: U, f: block(T, U) -> U) -> U {
     alt ls { nil. { u } cons(hd, tl) { f(hd, pure_foldl(*tl, f(hd, u), f)) } }
 }
 
 // Shows how to use an "unchecked" block to call a general
 // fn from a pure fn
-pure fn pure_length<T>(ls: list<T>) -> uint {
+pure fn pure_length<copy T>(ls: list<T>) -> uint {
     fn count<T>(_t: T, &&u: uint) -> uint { u + 1u }
     unchecked{ pure_foldl(ls, 0u, bind count(_, _)) }
 }
 
-pure fn nonempty_list<T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
+pure fn nonempty_list<copy T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
 
 // Of course, the compiler can't take advantage of the
 // knowledge that ls is a cons node. Future work.
 // Also, this is pretty contrived since nonempty_list
 // could be a "tag refinement", if we implement those.
-fn safe_head<T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
+fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
 
 fn main() {
     let mylist = cons(@1u, @nil);
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index dfff2490b05..372cca1c667 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -1,4 +1,4 @@
-fn f<T>(t: T) -> T {
+fn f<copy T>(t: T) -> T {
     let t1 = t;
     t1
 }
diff --git a/src/test/run-pass/unique-generic-assign.rs b/src/test/run-pass/unique-generic-assign.rs
index 3f692a59db7..4370bb4a791 100644
--- a/src/test/run-pass/unique-generic-assign.rs
+++ b/src/test/run-pass/unique-generic-assign.rs
@@ -1,6 +1,6 @@
 // Issue #976
 
-fn f<T>(x: ~T) {
+fn f<copy T>(x: ~T) {
     let _x2 = x;
 }
 fn main() { }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index da8babb0b9a..ab88437331c 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -1,10 +1,10 @@
-fn unique() {
+fn sendable() {
 
-    fn f<uniq T>(i: T, j: T) {
+    fn f<send T>(i: T, j: T) {
         assert i == j;
     }
 
-    fn g<uniq T>(i: T, j: T) {
+    fn g<send T>(i: T, j: T) {
         assert i != j;
     }
 
@@ -16,13 +16,13 @@ fn unique() {
     g(i, j);
 }
 
-fn shared() {
+fn copyable() {
 
-    fn f<T>(i: T, j: T) {
+    fn f<copy T>(i: T, j: T) {
         assert i == j;
     }
 
-    fn g<T>(i: T, j: T) {
+    fn g<copy T>(i: T, j: T) {
         assert i != j;
     }
 
@@ -34,13 +34,13 @@ fn shared() {
     g(i, j);
 }
 
-fn pinned() {
+fn noncopyable() {
 
-    fn f<pin T>(i: T, j: T) {
+    fn f<T>(i: T, j: T) {
         assert i == j;
     }
 
-    fn g<pin T>(i: T, j: T) {
+    fn g<T>(i: T, j: T) {
         assert i != j;
     }
 
@@ -53,7 +53,7 @@ fn pinned() {
 }
 
 fn main() {
-    unique();
-    shared();
-    pinned();
-}
\ No newline at end of file
+    sendable();
+    copyable();
+    noncopyable();
+}
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 8cdd5e82f18..92da692e482 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -1,5 +1,5 @@
 
 
-fn push<T>(&v: [const T], t: T) { v += [t]; }
+fn push<copy T>(&v: [const T], t: T) { v += [t]; }
 
 fn main() { let v = [1, 2, 3]; push(v, 1); }
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index fac7aa3a853..7a488475b9d 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -81,7 +81,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
 
 type eqfn<T> = fn@(T, T) -> bool;
 
-fn test_parameterized<T>(e: eqfn<T>, a: T, b: T, c: T, d: T) {
+fn test_parameterized<copy T>(e: eqfn<T>, a: T, b: T, c: T, d: T) {
     let deq: deque::t<T> = deque::create::<T>();
     assert (deq.size() == 0u);
     deq.add_front(a);
diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index 4e968e57942..a444fbbcc08 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -68,7 +68,7 @@ fn test_join_convenient() {
 #[ignore]
 fn spawn_polymorphic() {
     // FIXME #1038: Can't spawn palymorphic functions
-    /*fn foo<uniq T>(x: T) { log_err x; }
+    /*fn foo<send T>(x: T) { log_err x; }
 
     task::spawn(true, foo);
     task::spawn(42, foo);*/