lots of work to make iface/impls parameterized by regions

- paths can now take region parameters, replacing the dirty hack
  I was doing before of abusing vstores.  vstores are now a bit
  of a hack though.

- fix various small bugs:
  - we never checked that iface types were compatible when casting
    to an iface with `as`
  - we allowed nonsense like int<int>
  - and more! (actually that may be it)

Author: nikomatsakis

src/librustsyntax/ast.rs

@@ -37,7 +37,11 @@ type ident = str;
 type fn_ident = option<ident>;
 
 #[auto_serialize]
-type path = {span: span, global: bool, idents: [ident], types: [@ty]};
+type path = {span: span,
+             global: bool,
+             idents: [ident],
+             rp: option<@region>,
+             types: [@ty]};
 
 #[auto_serialize]
 type crate_num = int;
@@ -175,7 +179,7 @@ enum vstore {
     vstore_fixed(option<uint>),   // [1,2,3,4]/_ or 4
     vstore_uniq,                  // [1,2,3,4]/~
     vstore_box,                   // [1,2,3,4]/@
-    vstore_slice(region)          // [1,2,3,4]/&(foo)?
+    vstore_slice(@region)         // [1,2,3,4]/&(foo)?
 }
 
 pure fn is_blockish(p: ast::proto) -> bool {
@@ -462,7 +466,7 @@ enum ty_ {
     ty_uniq(mt),
     ty_vec(mt),
     ty_ptr(mt),
-    ty_rptr(region, mt),
+    ty_rptr(@region, mt),
     ty_rec([ty_field]),
     ty_fn(proto, fn_decl),
     ty_tup([@ty]),
@@ -671,8 +675,8 @@ enum item_ {
                class_ctor,
                region_param
                ),
-    item_iface([ty_param], [ty_method]),
-    item_impl([ty_param], option<@iface_ref> /* iface */,
+    item_iface([ty_param], region_param, [ty_method]),
+    item_impl([ty_param], region_param, option<@iface_ref> /* iface */,
               @ty /* self */, [@method]),
 }
 

src/librustsyntax/ast_util.rs

@@ -248,7 +248,8 @@ fn default_block(stmts1: [@stmt], expr1: option<@expr>, id1: node_id) ->
 }
 
 fn ident_to_path(s: span, i: ident) -> @path {
-    @{span: s, global: false, idents: [i], types: []}
+    @{span: s, global: false, idents: [i],
+      rp: none, types: []}
 }
 
 pure fn is_unguarded(&&a: arm) -> bool {

src/librustsyntax/ext/auto_serialize.rs

@@ -130,11 +130,11 @@ impl helpers for ext_ctxt {
     }
 
     fn path(span: span, strs: [str]) -> @ast::path {
-        @{span: span, global: false, idents: strs, types: []}
+        @{span: span, global: false, idents: strs, rp: none, types: []}
     }
 
     fn path_tps(span: span, strs: [str], tps: [@ast::ty]) -> @ast::path {
-        @{span: span, global: false, idents: strs, types: tps}
+        @{span: span, global: false, idents: strs, rp: none, types: tps}
     }
 
     fn ty_path(span: span, strs: [str], tps: [@ast::ty]) -> @ast::ty {
@@ -193,7 +193,8 @@ impl helpers for ext_ctxt {
     }
 
     fn binder_pat(span: span, nm: str) -> @ast::pat {
-        let path = @{span: span, global: false, idents: [nm], types: []};
+        let path = @{span: span, global: false, idents: [nm],
+                     rp: none, types: []};
         @{id: self.next_id(),
           node: ast::pat_ident(path, none),
           span: span}

src/librustsyntax/ext/build.rs

@@ -30,7 +30,8 @@ fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
 }
 fn mk_path(cx: ext_ctxt, sp: span, idents: [ast::ident]) ->
     @ast::expr {
-    let path = @{span: sp, global: false, idents: idents, types: []};
+    let path = @{span: sp, global: false, idents: idents,
+                 rp: none, types: []};
     let pathexpr = ast::expr_path(path);
     ret @{id: cx.next_id(), node: pathexpr, span: sp};
 }

src/librustsyntax/ext/concat_idents.rs

@@ -17,6 +17,6 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
 
     ret @{id: cx.next_id(),
           node: ast::expr_path(@{span: sp, global: false, idents: [res],
-                                 types: []}),
+                                 rp: none, types: []}),
           span: sp};
 }

src/librustsyntax/ext/simplext.rs

@@ -334,7 +334,8 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
     if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
     alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
       some(match_ident(id)) {
-        {span: id.span, global: false, idents: [id.node], types: []}
+        {span: id.span, global: false, idents: [id.node],
+         rp: none, types: []}
       }
       some(match_path(a_pth)) { *a_pth }
       some(m) { match_error(cx, m, "a path") }
@@ -359,6 +360,7 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
                 (expr_path(@{span: id.span,
                              global: false,
                              idents: [id.node],
+                             rp: none,
                              types: []}), id.span)
               }
               some(match_path(a_pth)) { (expr_path(a_pth), s) }

src/librustsyntax/fold.rs

@@ -287,12 +287,18 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                    with ctor},
                   rp)
           }
-          item_impl(tps, ifce, ty, methods) {
-              item_impl(tps, option::map(ifce, {|p| fold_iface_ref(p, fld)}),
+          item_impl(tps, rp, ifce, ty, methods) {
+              item_impl(fold_ty_params(tps, fld),
+                        rp,
+                        ifce.map { |p| fold_iface_ref(p, fld) },
                         fld.fold_ty(ty),
-                      vec::map(methods, fld.fold_method))
+                        vec::map(methods, fld.fold_method))
+          }
+          item_iface(tps, rp, methods) {
+            item_iface(fold_ty_params(tps, fld),
+                       rp,
+                       methods)
           }
-          item_iface(tps, methods) { item_iface(tps, methods) }
           item_res(decl, typms, body, did, cid, rp) {
             item_res(fold_fn_decl(decl, fld),
                      fold_ty_params(typms, fld),
@@ -565,6 +571,7 @@ fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { ret i; }
 fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
     ret {span: fld.new_span(p.span), global: p.global,
          idents: vec::map(p.idents, fld.fold_ident),
+         rp: p.rp,
          types: vec::map(p.types, fld.fold_ty)};
 }