Turn on kind propagation for typarams. Annotate a bunch of typarams in rustc and libstd.

graydon · graydon · commit f3c05b9faec1 · 2011-07-29T12:58:52.000-07:00
diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
@@ -150,7 +150,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->
     }
 }
 
-fn parse_constr[T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->
+fn parse_constr[@T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->
    @ty::constr_general[T] {
     let sp = {lo: 0u, hi: 0u}; // FIXME: use a real span
     let args: (@sp_constr_arg[T])[] = ~[];
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
@@ -1129,10 +1129,7 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
       ty_var(_) { fail; }
 
       ty_param(_,k) {
-        // FIXME: when you turn this on, the stdlib will break; be sure
-        // to have a snapshot done that understands kinds before doing so.
-
-        // result = kind::lower_kind(result, k);
+        result = kind::lower_kind(result, k);
       }
 
       ty_constr(t, _) {
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
@@ -16,7 +16,7 @@ type t[T] =
         fn get(int) -> T ;
     };
 
-fn create[T]() -> t[T] {
+fn create[@T]() -> t[T] {
     type cell[T] = option::t[T];
 
     let initial_capacity: uint = 32u; // 2^5
@@ -26,7 +26,7 @@ fn create[T]() -> t[T] {
       */
 
 
-    fn grow[T](nelts: uint, lo: uint, elts: &(cell[T])[mutable ]) ->
+    fn grow[@T](nelts: uint, lo: uint, elts: &(cell[T])[mutable ]) ->
        (cell[T])[mutable ] {
         assert (nelts == ivec::len(elts));
         let rv = ~[mutable ];
@@ -42,13 +42,13 @@ fn create[T]() -> t[T] {
 
         ret rv;
     }
-    fn get[T](elts: &(cell[T])[mutable ], i: uint) -> T {
+    fn get[@T](elts: &(cell[T])[mutable ], i: uint) -> T {
         ret alt elts.(i) { option::some(t) { t } _ { fail } };
     }
-    obj deque[T](mutable nelts: uint,
-                 mutable lo: uint,
-                 mutable hi: uint,
-                 mutable elts: (cell[T])[mutable ]) {
+    obj deque[@T](mutable nelts: uint,
+                  mutable lo: uint,
+                  mutable hi: uint,
+                  mutable elts: (cell[T])[mutable ]) {
         fn size() -> uint { ret nelts; }
         fn add_front(t: &T) {
             let oldlo: uint = lo;
diff --git a/src/lib/ivec.rs b/src/lib/ivec.rs
@@ -168,7 +168,7 @@ fn grow_fn[T](v: &mutable T[], n: uint, init_fn: fn(uint) -> T ) {
 /// Sets the element at position `index` to `val`. If `index` is past the end
 /// of the vector, expands the vector by replicating `initval` to fill the
 /// intervening space.
-fn grow_set[T](v: &mutable T[mutable ], index: uint, initval: &T, val: &T) {
+fn grow_set[@T](v: &mutable T[mutable ], index: uint, initval: &T, val: &T) {
     if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }
     v.(index) = val;
 }
diff --git a/src/lib/list.rs b/src/lib/list.rs
@@ -8,7 +8,7 @@ import option::none;
 // our recursion rules do not permit that.
 tag list[T] { cons(T, @list[T]); nil; }
 
-fn from_vec[T](v: vec[T]) -> list[T] {
+fn from_vec[@T](v: vec[T]) -> list[T] {
     let l = nil[T];
     // FIXME: This would be faster and more space efficient if it looped over
     // a reverse vector iterator. Unfortunately generic iterators seem not to
@@ -18,7 +18,7 @@ fn from_vec[T](v: vec[T]) -> list[T] {
     ret l;
 }
 
-fn foldl[T, U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
+fn foldl[@T, @U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
     let accum: U = u;
     let ls = ls_;
     while true {
@@ -30,7 +30,7 @@ fn foldl[T, U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
     ret accum;
 }
 
-fn find[T, U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> option::t[U] {
+fn find[@T, @U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> option::t[U] {
     let ls = ls_;
     while true {
         alt ls {
@@ -43,7 +43,7 @@ fn find[T, U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> option::t[U] {
     ret none;
 }
 
-fn has[T](ls_: &list[T], elt: &T) -> bool {
+fn has[@T](ls_: &list[T], elt: &T) -> bool {
     let ls = ls_;
     while true {
         alt ls {
@@ -60,11 +60,11 @@ fn length[T](ls: &list[T]) -> uint {
     ret foldl[T, uint](ls, 0u, bind count[T](_, _));
 }
 
-fn cdr[T](ls: &list[T]) -> list[T] { alt ls { cons(_, tl) { ret *tl; } } }
+fn cdr[@T](ls: &list[T]) -> list[T] { alt ls { cons(_, tl) { ret *tl; } } }
 
-fn car[T](ls: &list[T]) -> T { alt ls { cons(hd, _) { ret hd; } } }
+fn car[@T](ls: &list[T]) -> T { alt ls { cons(hd, _) { ret hd; } } }
 
-fn append[T](l: &list[T], m: &list[T]) -> list[T] {
+fn append[@T](l: &list[T], m: &list[T]) -> list[T] {
     alt l {
       nil. { ret m; }
       cons(x, xs) {
diff --git a/src/lib/map.rs b/src/lib/map.rs
@@ -19,9 +19,9 @@ type hashmap[K, V] =
     };
 type hashset[K] = hashmap[K, ()];
 
-fn set_add[K](set: hashset[K], key: &K) -> bool { ret set.insert(key, ()); }
+fn set_add[@K](set: hashset[K], key: &K) -> bool { ret set.insert(key, ()); }
 
-fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
+fn mk_hashmap[@K, @V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
     let initial_capacity: uint = 32u; // 2^5
 
     let load_factor: util::rational = {num: 3, den: 4};
@@ -53,10 +53,10 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
      * will fail.
      */
 
-    fn insert_common[K,
-                     V](hasher: &hashfn[K], eqer: &eqfn[K],
-                        bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K,
-                        val: &V) -> bool {
+    fn insert_common[@K,
+                     @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                         bkts: &(bucket[K, V])[mutable ], nbkts: uint,
+                         key: &K, val: &V) -> bool {
         let i: uint = 0u;
         let h: uint = hasher(key);
         while i < nbkts {
@@ -78,9 +78,9 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
         fail; // full table
 
     }
-    fn find_common[K,
-                   V](hasher: &hashfn[K], eqer: &eqfn[K],
-                      bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K)
+    fn find_common[@K,
+                   @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                       bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K)
        -> option::t[V] {
         let i: uint = 0u;
         let h: uint = hasher(key);
@@ -101,10 +101,10 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
         }
         ret option::none[V];
     }
-    fn rehash[K,
-              V](hasher: &hashfn[K], eqer: &eqfn[K],
-                 oldbkts: &(bucket[K, V])[mutable ], noldbkts: uint,
-                 newbkts: &(bucket[K, V])[mutable ], nnewbkts: uint) {
+    fn rehash[@K,
+              @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                  oldbkts: &(bucket[K, V])[mutable ], noldbkts: uint,
+                  newbkts: &(bucket[K, V])[mutable ], nnewbkts: uint) {
         for b: bucket[K, V]  in oldbkts {
             alt b {
               some(k_, v_) {
@@ -116,13 +116,13 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
             }
         }
     }
-    obj hashmap[K,
-                V](hasher: hashfn[K],
-                   eqer: eqfn[K],
-                   mutable bkts: (bucket[K, V])[mutable ],
-                   mutable nbkts: uint,
-                   mutable nelts: uint,
-                   lf: util::rational) {
+    obj hashmap[@K,
+                @V](hasher: hashfn[K],
+                    eqer: eqfn[K],
+                    mutable bkts: (bucket[K, V])[mutable ],
+                    mutable nbkts: uint,
+                    mutable nelts: uint,
+                    lf: util::rational) {
         fn size() -> uint { ret nelts; }
         fn insert(key: &K, val: &V) -> bool {
             let load: util::rational =
@@ -199,17 +199,17 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
 
 // Hash map constructors for basic types
 
-fn new_str_hash[V]() -> hashmap[str, V] {
+fn new_str_hash[@V]() -> hashmap[str, V] {
     ret mk_hashmap(str::hash, str::eq);
 }
 
-fn new_int_hash[V]() -> hashmap[int, V] {
+fn new_int_hash[@V]() -> hashmap[int, V] {
     fn hash_int(x: &int) -> uint { ret x as uint; }
     fn eq_int(a: &int, b: &int) -> bool { ret a == b; }
     ret mk_hashmap[int, V](hash_int, eq_int);
 }
 
-fn new_uint_hash[V]() -> hashmap[uint, V] {
+fn new_uint_hash[@V]() -> hashmap[uint, V] {
     fn hash_uint(x: &uint) -> uint { ret x; }
     fn eq_uint(a: &uint, b: &uint) -> bool { ret a == b; }
     ret mk_hashmap[uint, V](hash_uint, eq_uint);
diff --git a/src/lib/sort.rs b/src/lib/sort.rs
@@ -11,7 +11,7 @@ export quick_sort3;
 
 type lteq[T] = fn(&T, &T) -> bool ;
 
-fn merge_sort[T](le: lteq[T], v: vec[T]) -> vec[T] {
+fn merge_sort[@T](le: lteq[T], v: vec[T]) -> vec[T] {
     fn merge[T](le: lteq[T], a: vec[T], b: vec[T]) -> vec[T] {
         let rs: vec[T] = [];
         let a_len: uint = len[T](a);
@@ -36,13 +36,13 @@ fn merge_sort[T](le: lteq[T], v: vec[T]) -> vec[T] {
     ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
 }
 
-fn swap[T](arr: vec[mutable T], x: uint, y: uint) {
+fn swap[@T](arr: vec[mutable T], x: uint, y: uint) {
     let a = arr.(x);
     arr.(x) = arr.(y);
     arr.(y) = a;
 }
 
-fn part[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
+fn part[@T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
            right: uint, pivot: uint) -> uint {
     let pivot_value = arr.(pivot);
     swap[T](arr, pivot, right);
@@ -59,7 +59,7 @@ fn part[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
     ret storage_index;
 }
 
-fn qsort[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
+fn qsort[@T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
             right: uint) {
     if right > left {
         let pivot = (left + right) / 2u;
@@ -72,7 +72,7 @@ fn qsort[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
     }
 }
 
-fn quick_sort[T](compare_func: lteq[T], arr: vec[mutable T]) {
+fn quick_sort[@T](compare_func: lteq[T], arr: vec[mutable T]) {
     if len[T](arr) == 0u { ret; }
     qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
 }
@@ -82,7 +82,7 @@ fn quick_sort[T](compare_func: lteq[T], arr: vec[mutable T]) {
 // http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
 // According to these slides this is the algorithm of choice for
 // 'randomly ordered keys, abstract compare' & 'small number of key values'
-fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+fn qsort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
              arr: vec[mutable T], left: int, right: int) {
     if right <= left { ret; }
     let v: T = arr.(right);
@@ -130,7 +130,7 @@ fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
     qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
 }
 
-fn quick_sort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+fn quick_sort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                   arr: vec[mutable T]) {
     if vec::len[T](arr) == 0u { ret; }
     qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
@@ -144,8 +144,8 @@ mod ivector {
 
     type lteq[T] = fn(&T, &T) -> bool ;
 
-    fn merge_sort[T](le: lteq[T], v: &T[]) -> T[] {
-        fn merge[T](le: lteq[T], a: &T[], b: &T[]) -> T[] {
+    fn merge_sort[@T](le: lteq[T], v: &T[]) -> T[] {
+        fn merge[@T](le: lteq[T], a: &T[], b: &T[]) -> T[] {
             let rs: T[] = ~[];
             let a_len: uint = ilen[T](a);
             let a_ix: uint = 0u;
@@ -169,13 +169,13 @@ mod ivector {
         ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
     }
 
-    fn swap[T](arr: &T[mutable ], x: uint, y: uint) {
+    fn swap[@T](arr: &T[mutable ], x: uint, y: uint) {
         let a = arr.(x);
         arr.(x) = arr.(y);
         arr.(y) = a;
     }
 
-    fn part[T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
+    fn part[@T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
                right: uint, pivot: uint) -> uint {
         let pivot_value = arr.(pivot);
         swap[T](arr, pivot, right);
@@ -192,7 +192,7 @@ mod ivector {
         ret storage_index;
     }
 
-    fn qsort[T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
+    fn qsort[@T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
                 right: uint) {
         if right > left {
             let pivot = (left + right) / 2u;
@@ -205,7 +205,7 @@ mod ivector {
         }
     }
 
-    fn quick_sort[T](compare_func: lteq[T], arr: &T[mutable ]) {
+    fn quick_sort[@T](compare_func: lteq[T], arr: &T[mutable ]) {
         if ilen[T](arr) == 0u { ret; }
         qsort[T](compare_func, arr, 0u, ilen[T](arr) - 1u);
     }
@@ -216,7 +216,7 @@ mod ivector {
     // According to these slides this is the algorithm of choice for
     // 'randomly ordered keys, abstract compare' & 'small number of key
     // values'
-    fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+    fn qsort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                  arr: &T[mutable ], left: int, right: int) {
         if right <= left { ret; }
         let v: T = arr.(right);
@@ -264,7 +264,7 @@ mod ivector {
         qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
     }
 
-    fn quick_sort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+    fn quick_sort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                       arr: &T[mutable ]) {
         if ilen[T](arr) == 0u { ret; }
         qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
diff --git a/src/lib/vec.rs b/src/lib/vec.rs
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs

Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`153`		`-fn parse_constr[T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->`
	`153`	`+fn parse_constr[@T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->`
`154`	`154`	`@ty::constr_general[T] {`
`155`	`155`	`let sp = {lo: 0u, hi: 0u}; // FIXME: use a real span`
`156`	`156`	`let args: (@sp_constr_arg[T])[] = ~[];`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ fn grow_fn[T](v: &mutable T[], n: uint, init_fn: fn(uint) -> T ) {`
`168`	`168`	/// Sets the element at position `index` to `val`. If `index` is past the end
`169`	`169`	/// of the vector, expands the vector by replicating `initval` to fill the
`170`	`170`	`/// intervening space.`
`171`		`-fn grow_set[T](v: &mutable T[mutable ], index: uint, initval: &T, val: &T) {`
	`171`	`+fn grow_set[@T](v: &mutable T[mutable ], index: uint, initval: &T, val: &T) {`
`172`	`172`	`if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }`
`173`	`173`	`v.(index) = val;`
`174`	`174`	`}`