---

yaml
---
r: 955
b: refs/heads/master
c: 9769b61
h: refs/heads/master
i:
  953: 5147a52
  951: 547aa3e
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 98e8c2ef21f6aab3dd3d4d328a1c8baf1f074ee4
+refs/heads/master: 9769b612261d6000b969ce466c4033f8445d3474

trunk/src/comp/front/ast.rs

@@ -170,7 +170,7 @@ type item = spanned[item_];
 tag item_ {
     item_fn(ident, _fn, vec[ty_param], def_id, ann);
     item_mod(ident, _mod, def_id);
-    item_ty(ident, @ty, def_id, ann);
+    item_ty(ident, @ty, vec[ty_param], def_id, ann);
     item_tag(ident, vec[variant], vec[ty_param], def_id);
 }
 

trunk/src/comp/front/parser.rs

@@ -1026,7 +1026,7 @@ impure fn parse_block(parser p) -> ast.block {
                             case (ast.item_mod(?i, _, _)) {
                                 index.insert(i, u-1u);
                             }
-                            case (ast.item_ty(?i, _, _, _)) {
+                            case (ast.item_ty(?i, _, _, _, _)) {
                                 index.insert(i, u-1u);
                             }
                         }
@@ -1112,11 +1112,13 @@ impure fn parse_item_type(parser p) -> tup(ast.ident, @ast.item) {
     auto lo = p.get_span();
     expect(p, token.TYPE);
     auto id = parse_ident(p);
+    auto tps = parse_ty_params(p);
+
     expect(p, token.EQ);
     auto ty = parse_ty(p);
     auto hi = p.get_span();
     expect(p, token.SEMI);
-    auto item = ast.item_ty(id, ty, p.next_def_id(), ast.ann_none);
+    auto item = ast.item_ty(id, ty, tps, p.next_def_id(), ast.ann_none);
     ret tup(id, @spanned(lo, hi, item));
 }
 

trunk/src/comp/middle/fold.rs

@@ -166,7 +166,8 @@ type ast_fold[ENV] =
          &ast._mod m, def_id id) -> @item)        fold_item_mod,
 
      (fn(&ENV e, &span sp, ident ident,
-         @ty t, def_id id, ann a) -> @item)       fold_item_ty,
+         @ty t, vec[ast.ty_param] ty_params,
+         def_id id, ann a) -> @item)              fold_item_ty,
 
      (fn(&ENV e, &span sp, ident ident,
          vec[ast.variant] variants,
@@ -550,9 +551,9 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
             ret fld.fold_item_mod(env_, i.span, ident, mm_, id);
         }
 
-        case (ast.item_ty(?ident, ?ty, ?id, ?ann)) {
+        case (ast.item_ty(?ident, ?ty, ?params, ?id, ?ann)) {
             let @ast.ty ty_ = fold_ty[ENV](env_, fld, ty);
-            ret fld.fold_item_ty(env_, i.span, ident, ty_, id, ann);
+            ret fld.fold_item_ty(env_, i.span, ident, ty_, params, id, ann);
         }
 
         case (ast.item_tag(?ident, ?variants, ?ty_params, ?id)) {
@@ -813,8 +814,9 @@ fn identity_fold_item_mod[ENV](&ENV e, &span sp, ident i,
 }
 
 fn identity_fold_item_ty[ENV](&ENV e, &span sp, ident i,
-                              @ty t, def_id id, ann a) -> @item {
-    ret @respan(sp, ast.item_ty(i, t, id, a));
+                              @ty t, vec[ast.ty_param] ty_params,
+                              def_id id, ann a) -> @item {
+    ret @respan(sp, ast.item_ty(i, t, ty_params, id, a));
 }
 
 fn identity_fold_item_tag[ENV](&ENV e, &span sp, ident i,
@@ -941,7 +943,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
 
          fold_item_fn   = bind identity_fold_item_fn[ENV](_,_,_,_,_,_,_),
          fold_item_mod  = bind identity_fold_item_mod[ENV](_,_,_,_,_),
-         fold_item_ty   = bind identity_fold_item_ty[ENV](_,_,_,_,_,_),
+         fold_item_ty   = bind identity_fold_item_ty[ENV](_,_,_,_,_,_,_),
          fold_item_tag  = bind identity_fold_item_tag[ENV](_,_,_,_,_,_),
 
          fold_block = bind identity_fold_block[ENV](_,_,_),

trunk/src/comp/middle/resolve.rs

@@ -35,7 +35,7 @@ fn lookup_name(&env e, ast.ident i) -> option.t[def] {
             case (ast.item_mod(_, _, ?id)) {
                 ret some[def](ast.def_mod(id));
             }
-            case (ast.item_ty(_, _, ?id, _)) {
+            case (ast.item_ty(_, _, _, ?id, _)) {
                 ret some[def](ast.def_ty(id));
             }
         }

trunk/src/comp/middle/typeck.rs

@@ -326,7 +326,7 @@ fn collect_item_types(@ast.crate crate) -> tup(@ast.crate, @ty_table) {
                 ret t_fn;
             }
 
-            case (ast.item_ty(?ident, ?referent_ty, ?def_id, _)) {
+            case (ast.item_ty(?ident, ?referent_ty, _, ?def_id, _)) {
                 if (item_to_ty.contains_key(def_id)) {
                     // Avoid repeating work.
                     check (item_to_ty.contains_key(def_id));
@@ -351,7 +351,7 @@ fn collect_item_types(@ast.crate crate) -> tup(@ast.crate, @ty_table) {
     auto id_to_ty_item = @common.new_def_hash[@ast.item]();
     for (@ast.item item in module.items) {
         alt (item.node) {
-            case (ast.item_ty(_, _, ?def_id, _)) {
+            case (ast.item_ty(_, _, _, ?def_id, _)) {
                 id_to_ty_item.insert(def_id, item);
             }
             case (_) { /* empty */ }
@@ -371,10 +371,10 @@ fn collect_item_types(@ast.crate crate) -> tup(@ast.crate, @ty_table) {
                 result = ast.item_fn(ident, fn_info, tps, def_id,
                                      ast.ann_type(t));
             }
-            case (ast.item_ty(?ident, ?referent_ty, ?def_id, _)) {
+            case (ast.item_ty(?ident, ?referent_ty, ?tps, ?def_id, _)) {
                 auto t = trans_ty_item_to_ty(id_to_ty_item, item_to_ty, it);
                 auto ann = ast.ann_type(t);
-                result = ast.item_ty(ident, referent_ty, def_id, ann);
+                result = ast.item_ty(ident, referent_ty, tps, def_id, ann);
             }
             case (ast.item_mod(_, _, _)) {
                 result = it.node;