---

yaml
---
r: 12548
b: refs/heads/master
c: 3c995fb
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f3f34bf09b2512cac0e77281d8f2249d64cf2743
+refs/heads/master: 3c995fb8f3676a313f5ac883e175cc5fe354e640
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/librustsyntax/ast.rs

@@ -645,21 +645,29 @@ type iface_ref = {path: @path, id: node_id};
 type item = {ident: ident, attrs: [attribute],
              id: node_id, node: item_, 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_native_mod(native_mod),
-    item_ty(@ty, [ty_param]),
-    item_enum([variant], [ty_param]),
+    item_ty(@ty, [ty_param], region_param),
+    item_enum([variant], [ty_param], region_param),
     item_res(fn_decl /* dtor */, [ty_param], blk /* dtor body */,
-             node_id /* dtor id */, node_id /* ctor id */),
+             node_id /* dtor id */, node_id /* ctor id */,
+             region_param),
     item_class([ty_param], /* ty params for class */
                [iface_ref],   /* ifaces this class implements */
                [@class_member], /* methods, etc. */
                                /* (not including ctor) */
-               class_ctor
+               class_ctor,
+               region_param
                ),
     item_iface([ty_param], [ty_method]),
     item_impl([ty_param], option<@ty> /* iface */,

trunk/src/librustsyntax/ast_util.rs

@@ -149,7 +149,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;

trunk/src/librustsyntax/ext/auto_serialize.rs

@@ -102,11 +102,11 @@ fn expand(cx: ext_ctxt,
 
     vec::flat_map(in_items) {|in_item|
         alt in_item.node {
-          ast::item_ty(ty, tps) {
+          ast::item_ty(ty, tps, _) {
             [filter_attrs(in_item)] + ty_fns(cx, in_item.ident, ty, tps)
           }
 
-          ast::item_enum(variants, tps) {
+          ast::item_enum(variants, tps, _) {
             [filter_attrs(in_item)] + enum_fns(cx, in_item.ident,
                                                in_item.span, variants, tps)
           }

trunk/src/librustsyntax/fold.rs

@@ -265,36 +265,42 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           }
           item_mod(m) { item_mod(fld.fold_mod(m)) }
           item_native_mod(nm) { item_native_mod(fld.fold_native_mod(nm)) }
-          item_ty(t, typms) { item_ty(fld.fold_ty(t),
-                                      fold_ty_params(typms, fld)) }
-          item_enum(variants, typms) {
+          item_ty(t, typms, rp) { item_ty(fld.fold_ty(t),
+                                          fold_ty_params(typms, fld),
+                                          rp) }
+          item_enum(variants, typms, r) {
             item_enum(vec::map(variants, fld.fold_variant),
-                      fold_ty_params(typms, fld))
+                      fold_ty_params(typms, fld),
+                      r)
           }
-          item_class(typms, ifaces, items, ctor) {
+          item_class(typms, ifaces, items, ctor, rp) {
               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);
-              item_class(typms, vec::map(ifaces, {|p|
-                              {path: fld.fold_path(p.path),
-                               id: fld.new_id(p.id)}}),
-                         vec::map(items, fld.fold_class_item),
-                         {node: {body: ctor_body,
-                                 dec: ctor_decl,
-                                 id: ctor_id with ctor.node}
-                             with ctor})
+              item_class(
+                  typms,
+                  vec::map(ifaces, {|p|
+                      {path: fld.fold_path(p.path),
+                       id: fld.new_id(p.id)}}),
+                  vec::map(items, fld.fold_class_item),
+                  {node: {body: ctor_body,
+                          dec: ctor_decl,
+                          id: ctor_id with ctor.node}
+                   with ctor},
+                  rp)
           }
           item_impl(tps, ifce, ty, methods) {
             item_impl(tps, option::map(ifce, fld.fold_ty), fld.fold_ty(ty),
                       vec::map(methods, fld.fold_method))
           }
           item_iface(tps, methods) { item_iface(tps, methods) }
-          item_res(decl, typms, body, did, cid) {
+          item_res(decl, typms, body, did, cid, rp) {
             item_res(fold_fn_decl(decl, fld),
                      fold_ty_params(typms, fld),
                      fld.fold_block(body),
                      fld.new_id(did),
-                     fld.new_id(cid))
+                     fld.new_id(cid),
+                     rp)
           }
         };
 }

trunk/src/librustsyntax/parse/parser.rs

@@ -1992,6 +1992,7 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
 fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
     let ident = parse_value_ident(p);
+    let rp = parse_region_param(p);
     let ty_params = parse_ty_params(p);
     expect(p, token::LPAREN);
     let arg_ident = parse_value_ident(p);
@@ -2010,7 +2011,8 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
          cf: ast::return_val,
          constraints: []};
     ret mk_item(p, lo, dtor.span.hi, ident,
-                ast::item_res(decl, ty_params, dtor, p.get_id(), p.get_id()),
+                ast::item_res(decl, ty_params, dtor,
+                              p.get_id(), p.get_id(), rp),
                 attrs);
 }
 
@@ -2035,6 +2037,7 @@ fn parse_iface_ref_list(p:parser) -> [ast::iface_ref] {
 fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
     let class_name = parse_value_ident(p);
+    let rp = parse_region_param(p);
     let ty_params = parse_ty_params(p);
     let class_path = ident_to_path_tys(p, class_name, ty_params);
     let ifaces : [ast::iface_ref] = if eat_word(p, "implements")
@@ -2057,11 +2060,11 @@ fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
       some((ct_d, ct_b, ct_s)) {
           ret mk_item(p, lo, p.last_span.hi, class_name,
                       ast::item_class(ty_params, ifaces, ms,
-                         {node: {id: ctor_id,
-                                 self_id: p.get_id(),
-                                 dec: ct_d,
-                                 body: ct_b},
-                          span: ct_s}), attrs); }
+                                      {node: {id: ctor_id,
+                                              self_id: p.get_id(),
+                                              dec: ct_d,
+                                              body: ct_b},
+                                       span: ct_s}, rp), attrs); }
        /*
          Is it strange for the parser to check this?
        */
@@ -2236,17 +2239,23 @@ fn parse_type_decl(p: parser) -> {lo: uint, ident: ast::ident} {
 
 fn parse_item_type(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let t = parse_type_decl(p);
+    let rp = parse_region_param(p);
     let tps = parse_ty_params(p);
     expect(p, token::EQ);
     let ty = parse_ty(p, false);
     let mut hi = p.span.hi;
     expect(p, token::SEMI);
-    ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
+    ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps, rp), attrs);
+}
+
+fn parse_region_param(p: parser) -> ast::region_param {
+    if eat(p, token::BINOP(token::AND)) {ast::rp_self} else {ast::rp_none}
 }
 
 fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
     let id = parse_ident(p);
+    let rp = parse_region_param(p);
     let ty_params = parse_ty_params(p);
     let mut variants: [ast::variant] = [];
     // Newtype syntax
@@ -2265,7 +2274,7 @@ fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item {
                      id: p.get_id(),
                      disr_expr: none});
         ret mk_item(p, lo, ty.span.hi, id,
-                    ast::item_enum([variant], ty_params), attrs);
+                    ast::item_enum([variant], ty_params, rp), attrs);
     }
     expect(p, token::LBRACE);
 
@@ -2301,7 +2310,7 @@ fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item {
         p.fatal("discriminator values can only be used with a c-like enum");
     }
     ret mk_item(p, lo, p.last_span.hi, id,
-                ast::item_enum(variants, ty_params), attrs);
+                ast::item_enum(variants, ty_params, rp), attrs);
 }
 
 fn parse_fn_ty_proto(p: parser) -> ast::proto {

trunk/src/librustsyntax/print/pprust.rs

@@ -125,10 +125,10 @@ fn test_fun_to_str() {
 }
 
 fn res_to_str(decl: ast::fn_decl, name: ast::ident,
-              params: [ast::ty_param]) -> str {
+              params: [ast::ty_param], rp: ast::region_param) -> str {
     let buffer = io::mem_buffer();
     let s = rust_printer(io::mem_buffer_writer(buffer));
-    print_res(s, decl, name, params);
+    print_res(s, decl, name, params, rp);
     end(s); // Close the head box
     end(s); // Close the outer box
     eof(s.s);
@@ -454,11 +454,12 @@ fn print_item(s: ps, &&item: @ast::item) {
         print_native_mod(s, nmod, item.attrs);
         bclose(s, item.span);
       }
-      ast::item_ty(ty, params) {
+      ast::item_ty(ty, params, rp) {
         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
 
@@ -468,7 +469,7 @@ fn print_item(s: ps, &&item: @ast::item) {
         word(s.s, ";");
         end(s); // end the outer ibox
       }
-      ast::item_enum(variants, params) {
+      ast::item_enum(variants, params, rp) {
         let newtype =
             vec::len(variants) == 1u &&
                 str::eq(item.ident, variants[0].node.name) &&
@@ -478,6 +479,7 @@ 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 {
@@ -500,9 +502,10 @@ fn print_item(s: ps, &&item: @ast::item) {
             bclose(s, item.span);
         }
       }
-      ast::item_class(tps,ifaces,items,ctor) {
+      ast::item_class(tps,ifaces,items,ctor, rp) {
           head(s, "class");
           word_nbsp(s, item.ident);
+          print_region_param(s, rp);
           print_type_params(s, tps);
           word_space(s, "implements");
           commasep(s, inconsistent, ifaces, {|s, p|
@@ -584,18 +587,19 @@ fn print_item(s: ps, &&item: @ast::item) {
         for methods.each {|meth| print_ty_method(s, meth); }
         bclose(s, item.span);
       }
-      ast::item_res(decl, tps, body, dt_id, ct_id) {
-        print_res(s, decl, item.ident, tps);
+      ast::item_res(decl, tps, body, dt_id, ct_id, rp) {
+        print_res(s, decl, item.ident, tps, rp);
         print_block(s, body);
       }
     }
     s.ann.post(ann_node);
 }
 
 fn print_res(s: ps, decl: ast::fn_decl, name: ast::ident,
-             typarams: [ast::ty_param]) {
+             typarams: [ast::ty_param], rp: ast::region_param) {
     head(s, "resource");
     word(s.s, name);
+    print_region_param(s, rp);
     print_type_params(s, typarams);
     popen(s);
     word_space(s, decl.inputs[0].ident + ":");
@@ -1401,6 +1405,13 @@ 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, "<");

trunk/src/librustsyntax/visit.rs

@@ -15,7 +15,7 @@ enum vt<E> { mk_vt(visitor<E>), }
 enum fn_kind {
     fk_item_fn(ident, [ty_param]), //< an item declared with fn()
     fk_method(ident, [ty_param], @method),
-    fk_res(ident, [ty_param]),
+    fk_res(ident, [ty_param], region_param),
     fk_anon(proto),  //< an anonymous function like fn@(...)
     fk_fn_block,     //< a block {||...}
     fk_ctor(ident, [ty_param], node_id /* self id */,
@@ -24,15 +24,15 @@ enum fn_kind {
 
 fn name_of_fn(fk: fn_kind) -> ident {
     alt fk {
-      fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _)
+      fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _, _)
           | fk_ctor(name, _, _, _) { name }
       fk_anon(_) | fk_fn_block { "anon" }
     }
 }
 
 fn tps_of_fn(fk: fn_kind) -> [ty_param] {
     alt fk {
-      fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps)
+      fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps, _)
           | fk_ctor(_, tps, _, _) { tps }
       fk_anon(_) | fk_fn_block { [] }
     }
@@ -118,12 +118,15 @@ 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_native_item(ni, e, v); }
       }
-      item_ty(t, tps) { v.visit_ty(t, e, v); v.visit_ty_params(tps, e, v); }
-      item_res(decl, tps, body, dtor_id, _) {
-        v.visit_fn(fk_res(i.ident, tps), decl, body, i.span,
+      item_ty(t, tps, rp) {
+        v.visit_ty(t, e, v);
+        v.visit_ty_params(tps, e, v);
+      }
+      item_res(decl, tps, body, dtor_id, _, rp) {
+        v.visit_fn(fk_res(i.ident, tps, rp), decl, body, i.span,
                    dtor_id, 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); }
@@ -137,7 +140,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
             visit_method_helper(m, e, v)
         }
       }
-      item_class(tps, ifaces, members, ctor) {
+      item_class(tps, ifaces, members, ctor, _) {
           v.visit_ty_params(tps, e, v);
           for members.each {|m|
              v.visit_class_item(m, e, v);