Move to short kind kinds words in test suite

Issue #1076

diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index d2c6b5f5a5d9d4ec3e51bfeb3369336ead84256e..af2a4e2889dd6824330be1d93f54bba261e93e22 100644 (file)
--- 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<unique K, unique V> = fn(K, V);
+    type putter<uniq K, uniq V> = fn(K, V);
 
     // FIXME: the first K1 parameter should probably be a -, but that
     // doesn't parse at the moment.
-    type mapper<unique K1, unique K2, unique V> = fn(K1, putter<K2, V>);
+    type mapper<uniq K1, uniq K2, uniq V> = fn(K1, putter<K2, V>);
 
-    type getter<unique V> = fn() -> option<V>;
+    type getter<uniq V> = fn() -> option<V>;
 
-    type reducer<unique K, unique V> = fn(K, getter<V>);
+    type reducer<uniq K, uniq V> = fn(K, getter<V>);
 
-    tag ctrl_proto<unique K, unique V> {
+    tag ctrl_proto<uniq K, uniq V> {
         find_reducer(K, chan<chan<reduce_proto<V>>>);
         mapper_done;
     }
 
-    tag reduce_proto<unique V> { emit_val(V); done; ref; release; }
+    tag reduce_proto<uniq V> { emit_val(V); done; ref; release; }
 
-    fn start_mappers<unique K1, unique K2,
-                     unique V>(map: mapper<K1, K2, V>,
+    fn start_mappers<uniq K1, uniq K2,
+                     uniq V>(map: mapper<K1, K2, V>,
                          ctrl: chan<ctrl_proto<K2, V>>, inputs: [K1]) ->
        [joinable_task] {
         let tasks = [];
@@ -84,15 +84,15 @@ fn start_mappers<unique K1, unique K2,
         ret tasks;
     }
 
-    fn map_task<unique K1, unique K2,
-                unique V>(-map: mapper<K1, K2, V>,
+    fn map_task<uniq K1, uniq K2,
+                uniq 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<unique K2,
-                unique V>(im: treemap::treemap<K2, chan<reduce_proto<V>>>,
+        fn emit<uniq K2,
+                uniq 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 @@ fn emit<unique K2,
 
         map(input, bind emit(intermediates, ctrl, _, _));
 
-        fn finish<unique K, unique V>(_k: K, v: chan<reduce_proto<V>>) {
+        fn finish<uniq K, uniq V>(_k: K, v: chan<reduce_proto<V>>) {
             send(v, release);
         }
         treemap::traverse(intermediates, finish);
         send(ctrl, mapper_done);
     }
 
-    fn reduce_task<unique K,
-                   unique V>(-reduce: reducer<K, V>, -key: K,
+    fn reduce_task<uniq K,
+                   uniq V>(-reduce: reducer<K, V>, -key: K,
                        -out: chan<chan<reduce_proto<V>>>) {
         let p = port();
 
@@ -127,7 +127,7 @@ fn reduce_task<unique K,
         let ref_count = 0;
         let is_done = false;
 
-        fn get<unique V>(p: port<reduce_proto<V>>,
+        fn get<uniq V>(p: port<reduce_proto<V>>,
                          &ref_count: int, &is_done: bool)
            -> option<V> {
             while !is_done || ref_count > 0 {
@@ -150,8 +150,8 @@ fn get<unique V>(p: port<reduce_proto<V>>,
         reduce(key, bind get(p, ref_count, is_done));
     }
 
-    fn map_reduce<unique K1, unique K2,
-                  unique V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>,
+    fn map_reduce<uniq K1, uniq K2,
+                  uniq V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>,
                       inputs: [K1]) {
         let ctrl = port();
 
@@ -194,7 +194,7 @@ fn map_reduce<unique K1, unique K2,
             }
         }
 
-        fn finish<unique K, unique V>(_k: K, v: chan<reduce_proto<V>>) {
+        fn finish<uniq K, uniq V>(_k: K, v: chan<reduce_proto<V>>) {
             send(v, done);
         }
         treemap::traverse(reducers, finish);

diff --git a/src/test/compile-fail/implicit-copy-2.rs b/src/test/compile-fail/implicit-copy-2.rs
index 4ff190ee405d43d1019d4f07ee08a5d313b66182..c56655ba322dbd55cd8202808a936e2727b7532a 100644 (file)
--- a/src/test/compile-fail/implicit-copy-2.rs
+++ b/src/test/compile-fail/implicit-copy-2.rs
@@ -4,7 +4,7 @@
     *i = *i + 1;
 }
 
-fn movearg<pinned T>(i: T) {
+fn movearg<pin T>(i: T) {
     // Implicit copy to mutate reference i
     let j <- i;
 }

diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs
index e217866882925be86a2bfad8297c1a9bf647d605..2504a4d689015130e4e56a8f64649bc947738b4c 100644 (file)
--- a/src/test/compile-fail/unique-unique-kind.rs
+++ b/src/test/compile-fail/unique-unique-kind.rs
@@ -1,6 +1,6 @@
 // error-pattern: needed unique type
 
-fn f<unique T>(i: T) {
+fn f<uniq T>(i: T) {
 }
 
 fn main() {

diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs
index 2a38a5f6d04d93213bbbd33ca8c115e764ef4083..7a70292f526510a248740fa24dbaa78c374888ef 100644 (file)
--- 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<unique T>(ch: _chan<T>, -data: T) { log ch; log data; fail; }
+fn send<uniq 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/run-fail/bug-811.rs b/src/test/run-fail/bug-811.rs
index 92e9062534af50c5158c231152efe2e3ce3dae40..c9ebbfe5d0841460d9084549497ca3f78b715bed 100644 (file)
--- a/src/test/run-fail/bug-811.rs
+++ b/src/test/run-fail/bug-811.rs
@@ -4,8 +4,8 @@
 type task_id = int;
 type port_id = int;
 
-type chan_t<unique T> = {task: task_id, port: port_id};
+type chan_t<uniq T> = {task: task_id, port: port_id};
 
-fn send<unique T>(ch: chan_t<T>, -data: T) { fail; }
+fn send<uniq 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 a648f0b560a5ac881b1e9fa229375eb622be5ca2..e9a4e0679b70d112cc48e3302555699463da5848 100644 (file)
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -5,7 +5,7 @@
 import std::comm::send;
 import std::comm::recv;
 
-fn echo<unique T>(c: chan<T>, oc: chan<chan<T>>) {
+fn echo<uniq 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/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs
index 9e14ab19228e218726846b28e9dbc319d3a08f35..6fe82172814dbbda43b3b4bec37ea69b77d709d2 100644 (file)
--- 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, unique B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B {
+fn fix_help<A, uniq B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B {
     ret f(bind fix_help(f, _), x);
 }
 
-fn fix<A, unique B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B {
+fn fix<A, uniq 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 19c59529870d00d503a3454665a240d613919451..e0da008d75c31a0f9fe6b9affc33989f929ea5da 100644 (file)
--- 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<unique T>(val: T, f: fn(T)) {
+fn spawn<uniq T>(val: T, f: fn(T)) {
     f(val);
 }
 

diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index dbcbdcfae1a947ab6461bcff150d1bb0aa779e48..d1b7598d35e4253e93ab49b33f19b1718a1c796f 100644 (file)
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -1,6 +1,6 @@
 
 
-fn id<unique T>(t: T) -> T { ret t; }
+fn id<uniq T>(t: T) -> T { ret t; }
 
 fn main() {
     let expected = ~100;

diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs
index f815fcfd534b2c3ddf8ea548edb79c94e3178496..96cc02337cc6607519c6491998bb3ec1f611d81c 100644 (file)
--- a/src/test/run-pass/resource-in-struct.rs
+++ b/src/test/run-pass/resource-in-struct.rs
@@ -5,7 +5,7 @@
 
 resource close_res(i: closable) { *i = false; }
 
-tag option<pinned T> { none; some(T); }
+tag option<pin T> { none; some(T); }
 
 fn sink(res: option<close_res>) { }
 

diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index 73c36e0cdb35cd5fe54f35eb64eab09139b7ac32..0cc9a45d062280a9ec0b928d2c33e73aa592bbbd 100644 (file)
--- 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::port;
 
 // tests that ctrl's type gets inferred properly
-type command<unique K, unique V> = {key: K, val: V};
+type command<uniq K, uniq V> = {key: K, val: V};
 
-fn cache_server<unique K, unique V>(c: chan<chan<command<K, V>>>) {
+fn cache_server<uniq K, uniq 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 293b1ae5118622b75ed3547d8f1d272108404c0e..445632e33b5443cf108b51bc24da59926691dbd0 100644 (file)
--- 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<T>(pinned: T) { }
+fn p_foo<pin T>(pinned: T) { }
 fn s_foo<T>(shared: T) { }
-fn u_foo<unique T>(unique: T) { }
+fn u_foo<uniq T>(unique: T) { }
 
 resource r(i: int) { }
 

diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 5378bddff2d8372f466c74975c03a0e234dfa630..da8babb0b9aa7e78f46b80b3b4ddf646dffe3c11 100644 (file)
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -1,10 +1,10 @@
 fn unique() {
 
-    fn f<unique T>(i: T, j: T) {
+    fn f<uniq T>(i: T, j: T) {
         assert i == j;
     }
 
-    fn g<unique T>(i: T, j: T) {
+    fn g<uniq T>(i: T, j: T) {
         assert i != j;
     }
 
@@ -36,11 +36,11 @@ fn g<T>(i: T, j: T) {
 
 fn pinned() {
 
-    fn f<T>(i: T, j: T) {
+    fn f<pin T>(i: T, j: T) {
         assert i == j;
     }
 
-    fn g<T>(i: T, j: T) {
+    fn g<pin T>(i: T, j: T) {
         assert i != j;
     }
 

diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index b12636a58c0d64c3c9124b7c6912fc5b98484ff2..1c983251937ed7d753369bf1f7a3b630a3fd1c90 100644 (file)
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -80,7 +80,7 @@ fn winner(&&_i: ()) { }
 #[ignore]
 fn spawn_polymorphic() {
     // FIXME #1038: Can't spawn palymorphic functions
-    /*fn foo<unique T>(x: T) { log_err x; }
+    /*fn foo<uniq T>(x: T) { log_err x; }
 
     task::spawn(true, foo);
     task::spawn(42, foo);*/