infer when types are region parameterized rather than requiring /&

- removes various fields from various variants in the AST
- also update tests not to use this notation

9 files changed, 75 insertions, 93 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 3df4a2aefa5..f7e990b1025 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -679,30 +679,23 @@ type item = {ident: ident, attrs: ~[attribute],
              vis: visibility, span: span};
 
 #[auto_serialize]
-enum region_param {
-    rp_none,
-    rp_self
-}
-
-#[auto_serialize]
 enum item_ {
     item_const(@ty, @expr),
     item_fn(fn_decl, ~[ty_param], blk),
     item_mod(_mod),
     item_foreign_mod(foreign_mod),
-    item_ty(@ty, ~[ty_param], region_param),
-    item_enum(~[variant], ~[ty_param], region_param),
+    item_ty(@ty, ~[ty_param]),
+    item_enum(~[variant], ~[ty_param]),
     item_class(~[ty_param], /* ty params for class */
                ~[@trait_ref],   /* traits this class implements */
                ~[@class_member], /* methods, etc. */
                                /* (not including ctor or dtor) */
                class_ctor,
                /* dtor is optional */
-               option<class_dtor>,
-               region_param
+               option<class_dtor>
                ),
-    item_trait(~[ty_param], region_param, ~[ty_method]),
-    item_impl(~[ty_param], region_param, option<@trait_ref> /* trait */,
+    item_trait(~[ty_param], ~[ty_method]),
+    item_impl(~[ty_param], option<@trait_ref> /* trait */,
               @ty /* self */, ~[@method]),
     item_mac(mac),
 }
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 79d6691caf1..129a03f71aa 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -188,14 +188,14 @@ fn map_item(i: @item, cx: ctx, v: vt) {
     let item_path = @/* FIXME (#2543) */ copy cx.path;
     cx.map.insert(i.id, node_item(i, item_path));
     alt i.node {
-      item_impl(_, _, _, _, ms) {
+      item_impl(_, _, _, ms) {
         let impl_did = ast_util::local_def(i.id);
         for ms.each |m| {
             map_method(impl_did, extend(cx, i.ident), m,
                        cx);
         }
       }
-      item_enum(vs, _, _) {
+      item_enum(vs, _) {
         for vs.each |v| {
             cx.map.insert(v.node.id, node_variant(
                 /* FIXME (#2543) */ copy v, i,
@@ -214,7 +214,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
                                            extend(cx, i.ident)));
         }
       }
-      item_class(tps, traits, items, ctor, dtor, _) {
+      item_class(tps, traits, items, ctor, dtor) {
           let (_, ms) = ast_util::split_class_items(items);
           // Map trait refs to their parent classes. This is
           // so we can find the self_ty
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 551c6817405..806f6c35ed0 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -155,7 +155,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
     for m.items.each |it| {
         if it.ident == i { local = true; }
         alt it.node {
-          item_enum(variants, _, _) {
+          item_enum(variants, _) {
             for variants.each |v| {
                 if v.node.name == i {
                    local = true;
@@ -428,7 +428,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
         visit_item: fn@(i: @item) {
             vfn(i.id);
             alt i.node {
-              item_enum(vs, _, _) { for vs.each |v| { vfn(v.node.id); } }
+              item_enum(vs, _) { for vs.each |v| { vfn(v.node.id); } }
               _ {}
             }
         },
@@ -519,6 +519,9 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
             }
         },
 
+        visit_ty_method: fn@(_ty_m: ty_method) {
+        },
+
         visit_class_item: fn@(c: @class_member) {
             alt c.node {
               instance_var(_, _, _, id,_) {
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index 64da3a7dcbd..6bbce757a92 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -102,12 +102,12 @@ fn expand(cx: ext_ctxt,
 
     do vec::flat_map(in_items) |in_item| {
         alt in_item.node {
-          ast::item_ty(ty, tps, _) {
+          ast::item_ty(ty, tps) {
             vec::append(~[filter_attrs(in_item)],
                         ty_fns(cx, in_item.ident, ty, tps))
           }
 
-          ast::item_enum(variants, tps, _) {
+          ast::item_enum(variants, tps) {
             vec::append(~[filter_attrs(in_item)],
                         enum_fns(cx, in_item.ident,
                                  in_item.span, variants, tps))
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index b23e707f4eb..ac0d507e61e 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -128,8 +128,7 @@ impl ast_builder for ext_ctxt {
                       +ty_params: ~[ast::ty_param]) -> @ast::item {
         self.item(name,
                   ast::item_enum(variants,
-                                 ty_params,
-                                 ast::rp_none))
+                                 ty_params))
     }
 
     fn item_enum(name: ident,
@@ -167,12 +166,10 @@ impl ast_builder for ext_ctxt {
     fn item_ty_poly(name: ident,
                     ty: @ast::ty,
                     +params: ~[ast::ty_param]) -> @ast::item {
-        self.item(name,
-                  ast::item_ty(ty, params, ast::rp_none))
+        self.item(name, ast::item_ty(ty, params))
     }
 
-    fn item_ty(name: ident,
-               ty: @ast::ty) -> @ast::item {
+    fn item_ty(name: ident, ty: @ast::ty) -> @ast::item {
         self.item_ty_poly(name, ty, ~[])
     }
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 01298675688..a78148b37c6 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -244,15 +244,13 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           }
           item_mod(m) { item_mod(fld.fold_mod(m)) }
           item_foreign_mod(nm) { item_foreign_mod(fld.fold_foreign_mod(nm)) }
-          item_ty(t, typms, rp) { item_ty(fld.fold_ty(t),
-                                          fold_ty_params(typms, fld),
-                                          rp) }
-          item_enum(variants, typms, r) {
+          item_ty(t, typms) { item_ty(fld.fold_ty(t),
+                                      fold_ty_params(typms, fld)) }
+          item_enum(variants, typms) {
             item_enum(vec::map(variants, |x| fld.fold_variant(x)),
-                      fold_ty_params(typms, fld),
-                      r)
+                      fold_ty_params(typms, fld))
           }
-          item_class(typms, traits, items, ctor, m_dtor, rp) {
+          item_class(typms, traits, items, ctor, m_dtor) {
               let ctor_body = fld.fold_block(ctor.node.body);
               let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
               let ctor_id   = fld.new_id(ctor.node.id);
@@ -269,18 +267,16 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                   {node: {body: ctor_body,
                           dec: ctor_decl,
                           id: ctor_id with ctor.node}
-                      with ctor}, dtor, rp)
+                      with ctor}, dtor)
           }
-          item_impl(tps, rp, ifce, ty, methods) {
+          item_impl(tps, ifce, ty, methods) {
               item_impl(fold_ty_params(tps, fld),
-                        rp,
                         ifce.map(|p| fold_trait_ref(p, fld)),
                         fld.fold_ty(ty),
                         vec::map(methods, |x| fld.fold_method(x)))
           }
-          item_trait(tps, rp, methods) {
+          item_trait(tps, methods) {
             item_trait(fold_ty_params(tps, fld),
-                       rp,
                        /* FIXME (#2543) */ copy methods)
           }
       item_mac(m) {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 1a60d46f5e5..f4681ba2619 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -41,8 +41,8 @@ import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
              pat_box, pat_enum, pat_ident, pat_lit, pat_range, pat_rec,
              pat_tup, pat_uniq, pat_wild, path, private, proto, proto_any,
              proto_bare, proto_block, proto_box, proto_uniq, public, pure_fn,
-             purity, re_anon, re_named, region, region_param, rem, ret_style,
-             return_val, rp_none, rp_self, shl, shr, stmt, stmt_decl,
+             purity, re_anon, re_named, region, rem, ret_style,
+             return_val, shl, shr, stmt, stmt_decl,
              stmt_expr, stmt_semi, subtract, token_tree, trait_ref, tt_delim,
              tt_dotdotdot, tt_flat, tt_interpolate, ty, ty_, ty_bot, ty_box,
              ty_constr, ty_constr_, ty_constr_arg, ty_field, ty_fn, ty_infer,
@@ -2133,10 +2133,10 @@ class parser {
 
     fn parse_item_trait() -> item_info {
         let ident = self.parse_ident();
-        let rp = self.parse_region_param();
+        self.parse_region_param();
         let tps = self.parse_ty_params();
         let meths = self.parse_ty_methods();
-        (ident, item_trait(tps, rp, meths), none)
+        (ident, item_trait(tps, meths), none)
     }
 
     // Parses three variants (with the region/type params always optional):
@@ -2147,18 +2147,19 @@ class parser {
         fn wrap_path(p: parser, pt: @path) -> @ty {
             @{id: p.get_id(), node: ty_path(pt, p.get_id()), span: pt.span}
         }
-        let mut (ident, rp, tps) = {
+        let mut (ident, tps) = {
             if self.token == token::LT {
-                (none, rp_none, self.parse_ty_params())
+                (none, self.parse_ty_params())
             } else if self.token == token::BINOP(token::SLASH) {
-                (none, self.parse_region_param(), self.parse_ty_params())
+                self.parse_region_param();
+                (none, self.parse_ty_params())
             }
             else if self.is_keyword("of") {
-                (none, rp_none, ~[])
+                (none, ~[])
             } else {
                 let id = self.parse_ident();
-                let rp = self.parse_region_param();
-                (some(id), rp, self.parse_ty_params())
+                self.parse_region_param();
+                (some(id), self.parse_ty_params())
             }
         };
         let ifce = if self.eat_keyword("of") {
@@ -2179,25 +2180,18 @@ class parser {
         while !self.eat(token::RBRACE) {
             vec::push(meths, self.parse_method(public));
         }
-        (ident, item_impl(tps, rp, ifce, ty, meths), none)
+        (ident, item_impl(tps, ifce, ty, meths), none)
     }
 
     // Instantiates ident <i> with references to <typarams> as arguments.
     // Used to create a path that refers to a class which will be defined as
     // the return type of the ctor function.
     fn ident_to_path_tys(i: ident,
-                         rp: region_param,
                          typarams: ~[ty_param]) -> @path {
         let s = self.last_span;
 
-        // Hack.  But then, this whole function is in service of a hack.
-        let a_r = alt rp {
-          rp_none { none }
-          rp_self { some(self.region_from_name(some(@"self"))) }
-        };
-
         @{span: s, global: false, idents: ~[i],
-          rp: a_r,
+          rp: none,
           types: vec::map(typarams, |tp| {
               @{id: self.get_id(),
                 node: ty_path(ident_to_path(s, tp.ident), self.get_id()),
@@ -2218,9 +2212,9 @@ class parser {
 
     fn parse_item_class() -> item_info {
         let class_name = self.parse_value_ident();
-        let rp = self.parse_region_param();
+        self.parse_region_param();
         let ty_params = self.parse_ty_params();
-        let class_path = self.ident_to_path_tys(class_name, rp, ty_params);
+        let class_path = self.ident_to_path_tys(class_name, ty_params);
         let traits : ~[@trait_ref] = if self.eat(token::COLON)
             { self.parse_trait_ref_list() }
         else { ~[] };
@@ -2255,7 +2249,7 @@ class parser {
                         self_id: self.get_id(),
                         dec: ct_d,
                         body: ct_b},
-                 span: ct_s}, actual_dtor, rp),
+                 span: ct_s}, actual_dtor),
              none)
           }
           /*
@@ -2447,26 +2441,23 @@ class parser {
 
     fn parse_item_type() -> item_info {
         let t = self.parse_type_decl();
-        let rp = self.parse_region_param();
+        self.parse_region_param();
         let tps = self.parse_ty_params();
         self.expect(token::EQ);
         let ty = self.parse_ty(false);
         self.expect(token::SEMI);
-        (t.ident, item_ty(ty, tps, rp), none)
+        (t.ident, item_ty(ty, tps), none)
     }
 
-    fn parse_region_param() -> region_param {
+    fn parse_region_param() {
         if self.eat(token::BINOP(token::SLASH)) {
             self.expect(token::BINOP(token::AND));
-            rp_self
-        } else {
-            rp_none
         }
     }
 
     fn parse_item_enum(default_vis: visibility) -> item_info {
         let id = self.parse_ident();
-        let rp = self.parse_region_param();
+        self.parse_region_param();
         let ty_params = self.parse_ty_params();
         let mut variants: ~[variant] = ~[];
         // Newtype syntax
@@ -2483,7 +2474,7 @@ class parser {
                          id: self.get_id(),
                          disr_expr: none,
                          vis: public});
-            ret (id, item_enum(~[variant], ty_params, rp), none);
+            ret (id, item_enum(~[variant], ty_params), none);
         }
         self.expect(token::LBRACE);
 
@@ -2521,7 +2512,7 @@ class parser {
             self.fatal("discriminator values can only be used with a c-like \
                         enum");
         }
-        (id, item_enum(variants, ty_params, rp), none)
+        (id, item_enum(variants, ty_params), none)
     }
 
     fn parse_fn_ty_proto() -> proto {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 5453c3cf5eb..7e7dff4de12 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -458,12 +458,11 @@ fn print_item(s: ps, &&item: @ast::item) {
         print_foreign_mod(s, nmod, item.attrs);
         bclose(s, item.span);
       }
-      ast::item_ty(ty, params, rp) {
+      ast::item_ty(ty, params) {
         ibox(s, indent_unit);
         ibox(s, 0u);
         word_nbsp(s, "type");
         word(s.s, *item.ident);
-        print_region_param(s, rp);
         print_type_params(s, params);
         end(s); // end the inner ibox
 
@@ -473,7 +472,7 @@ fn print_item(s: ps, &&item: @ast::item) {
         word(s.s, ";");
         end(s); // end the outer ibox
       }
-      ast::item_enum(variants, params, rp) {
+      ast::item_enum(variants, params) {
         let newtype =
             vec::len(variants) == 1u &&
                 str::eq(*item.ident, *variants[0].node.name) &&
@@ -483,7 +482,6 @@ fn print_item(s: ps, &&item: @ast::item) {
             word_space(s, "enum");
         } else { head(s, "enum"); }
         word(s.s, *item.ident);
-        print_region_param(s, rp);
         print_type_params(s, params);
         space(s.s);
         if newtype {
@@ -506,10 +504,9 @@ fn print_item(s: ps, &&item: @ast::item) {
             bclose(s, item.span);
         }
       }
-      ast::item_class(tps, traits, items, ctor, m_dtor, rp) {
+      ast::item_class(tps, traits, items, ctor, m_dtor) {
           head(s, "class");
           word_nbsp(s, *item.ident);
-          print_region_param(s, rp);
           print_type_params(s, tps);
           if vec::len(traits) != 0u {
               word_space(s, ":");
@@ -571,10 +568,9 @@ fn print_item(s: ps, &&item: @ast::item) {
           }
           bclose(s, item.span);
        }
-      ast::item_impl(tps, rp, ifce, ty, methods) {
+      ast::item_impl(tps, ifce, ty, methods) {
         head(s, "impl");
         word(s.s, *item.ident);
-        print_region_param(s, rp);
         print_type_params(s, tps);
         space(s.s);
         option::iter(ifce, |p| {
@@ -591,10 +587,9 @@ fn print_item(s: ps, &&item: @ast::item) {
         }
         bclose(s, item.span);
       }
-      ast::item_trait(tps, rp, methods) {
+      ast::item_trait(tps, methods) {
         head(s, "iface");
         word(s.s, *item.ident);
-        print_region_param(s, rp);
         print_type_params(s, tps);
         word(s.s, " ");
         bopen(s);
@@ -1406,13 +1401,6 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
     }
 }
 
-fn print_region_param(s: ps, rp: ast::region_param) {
-    alt rp {
-      ast::rp_self { word(s.s, "/&") }
-      ast::rp_none { }
-    }
-}
-
 fn print_type_params(s: ps, &&params: ~[ast::ty_param]) {
     if vec::len(params) > 0u {
         word(s.s, "<");
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 51fd2e47c86..5dc42fd4823 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -61,6 +61,7 @@ type visitor<E> =
       visit_ty_params: fn@(~[ty_param], E, vt<E>),
       visit_constr: fn@(@path, span, node_id, E, vt<E>),
       visit_fn: fn@(fn_kind, fn_decl, blk, span, node_id, E, vt<E>),
+      visit_ty_method: fn@(ty_method, E, vt<E>),
       visit_class_item: fn@(@class_member, E, vt<E>)};
 
 fn default_visitor<E>() -> visitor<E> {
@@ -79,6 +80,7 @@ fn default_visitor<E>() -> visitor<E> {
           visit_ty_params: |a,b,c|visit_ty_params::<E>(a, b, c),
           visit_constr: |a,b,c,d,e|visit_constr::<E>(a, b, c, d, e),
           visit_fn: |a,b,c,d,e,f,g|visit_fn::<E>(a, b, c, d, e, f, g),
+          visit_ty_method: |a,b,c|visit_ty_method::<E>(a, b, c),
           visit_class_item: |a,b,c|visit_class_item::<E>(a, b, c)};
 }
 
@@ -125,17 +127,17 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
         for nm.view_items.each |vi| { v.visit_view_item(vi, e, v); }
         for nm.items.each |ni| { v.visit_foreign_item(ni, e, v); }
       }
-      item_ty(t, tps, rp) {
+      item_ty(t, tps) {
         v.visit_ty(t, e, v);
         v.visit_ty_params(tps, e, v);
       }
-      item_enum(variants, tps, _) {
+      item_enum(variants, tps) {
         v.visit_ty_params(tps, e, v);
         for variants.each |vr| {
             for vr.node.args.each |va| { v.visit_ty(va.ty, e, v); }
         }
       }
-      item_impl(tps, _rp, ifce, ty, methods) {
+      item_impl(tps, ifce, ty, methods) {
         v.visit_ty_params(tps, e, v);
         option::iter(ifce, |p| visit_path(p.path, e, v));
         v.visit_ty(ty, e, v);
@@ -143,7 +145,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
             visit_method_helper(m, e, v)
         }
       }
-      item_class(tps, traits, members, ctor, m_dtor, _) {
+      item_class(tps, traits, members, ctor, m_dtor) {
           v.visit_ty_params(tps, e, v);
           for members.each |m| {
              v.visit_class_item(m, e, v);
@@ -155,12 +157,10 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
                   visit_class_dtor_helper(dtor, tps,
                      ast_util::local_def(i.id), e, v)};
       }
-      item_trait(tps, _rp, methods) {
+      item_trait(tps, methods) {
         v.visit_ty_params(tps, e, v);
         for methods.each |m| {
-            for m.decl.inputs.each |a| { v.visit_ty(a.ty, e, v); }
-            v.visit_ty_params(m.tps, e, v);
-            v.visit_ty(m.decl.output, e, v);
+            v.visit_ty_method(m, e, v);
         }
       }
       item_mac(m) { visit_mac(m, e, v) }
@@ -311,6 +311,12 @@ fn visit_fn<E>(fk: fn_kind, decl: fn_decl, body: blk, _sp: span,
     v.visit_block(body, e, v);
 }
 
+fn visit_ty_method<E>(m: ty_method, e: E, v: vt<E>) {
+    for m.decl.inputs.each |a| { v.visit_ty(a.ty, e, v); }
+    v.visit_ty_params(m.tps, e, v);
+    v.visit_ty(m.decl.output, e, v);
+}
+
 fn visit_block<E>(b: ast::blk, e: E, v: vt<E>) {
     for b.node.view_items.each |vi| { v.visit_view_item(vi, e, v); }
     for b.node.stmts.each |s| { v.visit_stmt(s, e, v); }
@@ -458,6 +464,7 @@ type simple_visitor =
       visit_ty_params: fn@(~[ty_param]),
       visit_constr: fn@(@path, span, node_id),
       visit_fn: fn@(fn_kind, fn_decl, blk, span, node_id),
+      visit_ty_method: fn@(ty_method),
       visit_class_item: fn@(@class_member)};
 
 fn simple_ignore_ty(_t: @ty) {}
@@ -479,6 +486,7 @@ fn default_simple_visitor() -> simple_visitor {
           visit_constr: fn@(_p: @path, _sp: span, _id: node_id) { },
           visit_fn: fn@(_fk: fn_kind, _d: fn_decl, _b: blk, _sp: span,
                         _id: node_id) { },
+          visit_ty_method: fn@(_m: ty_method) { },
           visit_class_item: fn@(_c: @class_member) {}
          };
 }
@@ -534,6 +542,10 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
         f(ty);
         visit_ty(ty, e, v);
     }
+    fn v_ty_method(f: fn@(ty_method), ty: ty_method, &&e: (), v: vt<()>) {
+        f(ty);
+        visit_ty_method(ty, e, v);
+    }
     fn v_ty_params(f: fn@(~[ty_param]),
                    ps: ~[ty_param],
                    &&e: (), v: vt<()>) {
@@ -582,6 +594,8 @@ fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
                     v_constr(v.visit_constr, a, b, c, d, e),
                 visit_fn: |a,b,c,d,e,f,g|
                     v_fn(v.visit_fn, a, b, c, d, e, f, g),
+                visit_ty_method: |a,b,c|
+                    v_ty_method(v.visit_ty_method, a, b, c),
                 visit_class_item: |a,b,c|
                     v_class_item(v.visit_class_item, a, b, c)
                });