---

yaml
---
r: 44788
b: refs/heads/master
c: 5271464
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5f1652f34fee38f3d88f5944c86f159c0f7d7fee
+refs/heads/master: 5271464cc0aae453e96ad70a33e0c9636df7f90e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libsyntax/ext/auto_encode.rs

@@ -143,8 +143,8 @@ pub fn expand_auto_encode(
                         cx,
                         item.span,
                         item.ident,
-                        *enum_def,
-                        *tps
+                        copy *enum_def,
+                        copy *tps
                     );
 
                     ~[filter_attrs(*item), ser_impl]
@@ -188,7 +188,7 @@ pub fn expand_auto_decode(
                         item.span,
                         item.ident,
                         struct_def.fields,
-                        *tps
+                        copy *tps
                     );
 
                     ~[filter_attrs(*item), deser_impl]
@@ -198,8 +198,8 @@ pub fn expand_auto_decode(
                         cx,
                         item.span,
                         item.ident,
-                        *enum_def,
-                        *tps
+                        copy *enum_def,
+                        copy *tps
                     );
 
                     ~[filter_attrs(*item), deser_impl]
@@ -346,7 +346,7 @@ priv impl ext_ctxt {
 
     fn lambda(+blk: ast::blk) -> @ast::expr {
         let ext_cx = self;
-        let blk_e = self.expr(blk.span, ast::expr_block(blk));
+        let blk_e = self.expr(copy blk.span, ast::expr_block(copy blk));
         quote_expr!( || $blk_e )
     }
 
@@ -840,14 +840,14 @@ fn mk_enum_ser_impl(
     cx: ext_ctxt,
     span: span,
     ident: ast::ident,
-    enum_def: ast::enum_def,
+    +enum_def: ast::enum_def,
     tps: ~[ast::ty_param]
 ) -> @ast::item {
     let body = mk_enum_ser_body(
         cx,
         span,
         ident,
-        enum_def.variants
+        copy enum_def.variants
     );
 
     mk_ser_impl(cx, span, ident, tps, body)
@@ -857,7 +857,7 @@ fn mk_enum_deser_impl(
     cx: ext_ctxt,
     span: span,
     ident: ast::ident,
-    enum_def: ast::enum_def,
+    +enum_def: ast::enum_def,
     tps: ~[ast::ty_param]
 ) -> @ast::item {
     let body = mk_enum_deser_body(
@@ -960,8 +960,14 @@ fn mk_enum_ser_body(
 ) -> @ast::expr {
     let arms = do variants.mapi |v_idx, variant| {
         match variant.node.kind {
-            ast::tuple_variant_kind(args) =>
-                ser_variant(cx, span, variant.node.name, v_idx, args),
+            ast::tuple_variant_kind(ref args) =>
+                ser_variant(
+                    cx,
+                    span,
+                    variant.node.name,
+                    v_idx,
+                    /*bad*/ copy *args
+                ),
             ast::struct_variant_kind(*) =>
                 fail!(~"struct variants unimplemented"),
             ast::enum_variant_kind(*) =>
@@ -1041,7 +1047,7 @@ fn mk_enum_deser_body(
 ) -> @ast::expr {
     let mut arms = do variants.mapi |v_idx, variant| {
         let body = match variant.node.kind {
-            ast::tuple_variant_kind(args) => {
+            ast::tuple_variant_kind(ref args) => {
                 if args.is_empty() {
                     // for a nullary variant v, do "v"
                     ext_cx.expr_path(span, ~[variant.node.name])
@@ -1051,7 +1057,7 @@ fn mk_enum_deser_body(
                         ext_cx,
                         span,
                         variant.node.name,
-                        args
+                        copy *args
                     )
                 }
             },
@@ -1074,7 +1080,7 @@ fn mk_enum_deser_body(
         }
     };
 
-    let quoted_expr = quote_expr!(
+    let quoted_expr = copy quote_expr!(
       ::core::sys::begin_unwind(~"explicit failure", ~"empty", 1);
     ).node;
 

trunk/src/libsyntax/ext/base.rs

@@ -192,7 +192,7 @@ pub trait ext_ctxt {
 }
 
 pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
-               cfg: ast::crate_cfg) -> ext_ctxt {
+               +cfg: ast::crate_cfg) -> ext_ctxt {
     struct CtxtRepr {
         parse_sess: @mut parse::ParseSess,
         cfg: ast::crate_cfg,
@@ -203,7 +203,7 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
     impl ext_ctxt for CtxtRepr {
         fn codemap(@mut self) -> @CodeMap { self.parse_sess.cm }
         fn parse_sess(@mut self) -> @mut parse::ParseSess { self.parse_sess }
-        fn cfg(@mut self) -> ast::crate_cfg { self.cfg }
+        fn cfg(@mut self) -> ast::crate_cfg { copy self.cfg }
         fn call_site(@mut self) -> span {
             match *self.backtrace {
                 Some(@ExpandedFrom(CallInfo {call_site: cs, _})) => cs,
@@ -214,15 +214,15 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
         fn backtrace(@mut self) -> Option<@ExpnInfo> { *self.backtrace }
         fn mod_push(@mut self, i: ast::ident) { self.mod_path.push(i); }
         fn mod_pop(@mut self) { self.mod_path.pop(); }
-        fn mod_path(@mut self) -> ~[ast::ident] { return self.mod_path; }
+        fn mod_path(@mut self) -> ~[ast::ident] { copy self.mod_path }
         fn bt_push(@mut self, ei: codemap::ExpnInfo) {
             match ei {
               ExpandedFrom(CallInfo {call_site: cs, callee: ref callee}) => {
                 *self.backtrace =
                     Some(@ExpandedFrom(CallInfo {
                         call_site: span {lo: cs.lo, hi: cs.hi,
                                          expn_info: *self.backtrace},
-                        callee: (*callee)}));
+                        callee: copy *callee}));
               }
             }
         }
@@ -269,12 +269,11 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
         fn set_trace_macros(@mut self, x: bool) {
             self.trace_mac = x
         }
-
         fn str_of(@mut self, id: ast::ident) -> ~str {
-            *self.parse_sess.interner.get(id)
+            copy *self.parse_sess.interner.get(id)
         }
         fn ident_of(@mut self, st: ~str) -> ast::ident {
-            self.parse_sess.interner.intern(@st)
+            self.parse_sess.interner.intern(@/*bad*/ copy st)
         }
     }
     let imp: @mut CtxtRepr = @mut CtxtRepr {
@@ -290,7 +289,7 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
 pub fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, err_msg: ~str) -> ~str {
     match expr.node {
       ast::expr_lit(l) => match l.node {
-        ast::lit_str(s) => return *s,
+        ast::lit_str(s) => copy *s,
         _ => cx.span_fatal(l.span, err_msg)
       },
       _ => cx.span_fatal(expr.span, err_msg)

trunk/src/libsyntax/ext/build.rs

@@ -26,7 +26,7 @@ pub struct Field {
 
 pub fn mk_expr(cx: ext_ctxt,
                sp: codemap::span,
-               expr: ast::expr_)
+               +expr: ast::expr_)
             -> @ast::expr {
     @ast::expr {
         id: cx.next_id(),
@@ -62,7 +62,7 @@ pub fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
     cx.next_id(); // see ast_util::op_expr_callee_id
     mk_expr(cx, sp, ast::expr_unary(op, e))
 }
-pub fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::path {
+pub fn mk_raw_path(sp: span, +idents: ~[ast::ident]) -> @ast::path {
     let p = @ast::path { span: sp,
                          global: false,
                          idents: idents,
@@ -71,7 +71,7 @@ pub fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::path {
     return p;
 }
 pub fn mk_raw_path_(sp: span,
-                    idents: ~[ast::ident],
+                    +idents: ~[ast::ident],
                     +types: ~[@ast::Ty])
                  -> @ast::path {
     @ast::path { span: sp,
@@ -80,25 +80,25 @@ pub fn mk_raw_path_(sp: span,
                  rp: None,
                  types: types }
 }
-pub fn mk_raw_path_global(sp: span, idents: ~[ast::ident]) -> @ast::path {
+pub fn mk_raw_path_global(sp: span, +idents: ~[ast::ident]) -> @ast::path {
     @ast::path { span: sp,
                  global: true,
                  idents: idents,
                  rp: None,
                  types: ~[] }
 }
-pub fn mk_path(cx: ext_ctxt, sp: span, idents: ~[ast::ident]) -> @ast::expr {
+pub fn mk_path(cx: ext_ctxt, sp: span, +idents: ~[ast::ident]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_path(mk_raw_path(sp, idents)))
 }
-pub fn mk_path_global(cx: ext_ctxt, sp: span, idents: ~[ast::ident])
+pub fn mk_path_global(cx: ext_ctxt, sp: span, +idents: ~[ast::ident])
                    -> @ast::expr {
     mk_expr(cx, sp, ast::expr_path(mk_raw_path_global(sp, idents)))
 }
 pub fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident)
                -> @ast::expr {
     mk_expr(cx, sp, ast::expr_field(p, m, ~[]))
 }
-pub fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident)
+pub fn mk_access(cx: ext_ctxt, sp: span, +p: ~[ast::ident], m: ast::ident)
               -> @ast::expr {
     let pathexpr = mk_path(cx, sp, p);
     return mk_access_(cx, sp, pathexpr, m);
@@ -107,21 +107,21 @@ pub fn mk_addr_of(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     return mk_expr(cx, sp, ast::expr_addr_of(ast::m_imm, e));
 }
 pub fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr,
-                args: ~[@ast::expr]) -> @ast::expr {
+                +args: ~[@ast::expr]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_call(fn_expr, args, ast::NoSugar))
 }
-pub fn mk_call(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
-               args: ~[@ast::expr]) -> @ast::expr {
+pub fn mk_call(cx: ext_ctxt, sp: span, +fn_path: ~[ast::ident],
+               +args: ~[@ast::expr]) -> @ast::expr {
     let pathexpr = mk_path(cx, sp, fn_path);
     return mk_call_(cx, sp, pathexpr, args);
 }
-pub fn mk_call_global(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
-                      args: ~[@ast::expr]) -> @ast::expr {
+pub fn mk_call_global(cx: ext_ctxt, sp: span, +fn_path: ~[ast::ident],
+                      +args: ~[@ast::expr]) -> @ast::expr {
     let pathexpr = mk_path_global(cx, sp, fn_path);
     return mk_call_(cx, sp, pathexpr, args);
 }
 // e = expr, t = type
-pub fn mk_base_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+pub fn mk_base_vec_e(cx: ext_ctxt, sp: span, +exprs: ~[@ast::expr])
                   -> @ast::expr {
     let vecexpr = ast::expr_vec(exprs, ast::m_imm);
     mk_expr(cx, sp, vecexpr)
@@ -131,25 +131,25 @@ pub fn mk_vstore_e(cx: ext_ctxt, sp: span, expr: @ast::expr,
    @ast::expr {
     mk_expr(cx, sp, ast::expr_vstore(expr, vst))
 }
-pub fn mk_uniq_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+pub fn mk_uniq_vec_e(cx: ext_ctxt, sp: span, +exprs: ~[@ast::expr])
                   -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::expr_vstore_uniq)
 }
-pub fn mk_slice_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+pub fn mk_slice_vec_e(cx: ext_ctxt, sp: span, +exprs: ~[@ast::expr])
                    -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs),
                 ast::expr_vstore_slice)
 }
-pub fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+pub fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, +exprs: ~[@ast::expr])
                    -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs),
                 ast::expr_vstore_fixed(None))
 }
-pub fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
+pub fn mk_base_str(cx: ext_ctxt, sp: span, +s: ~str) -> @ast::expr {
     let lit = ast::lit_str(@s);
     return mk_lit(cx, sp, lit);
 }
-pub fn mk_uniq_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
+pub fn mk_uniq_str(cx: ext_ctxt, sp: span, +s: ~str) -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_str(cx, sp, s), ast::expr_vstore_uniq)
 }
 pub fn mk_field(sp: span, f: &Field) -> ast::field {
@@ -161,28 +161,36 @@ pub fn mk_field(sp: span, f: &Field) -> ast::field {
 pub fn mk_fields(sp: span, fields: ~[Field]) -> ~[ast::field] {
     fields.map(|f| mk_field(sp, f))
 }
-pub fn mk_rec_e(cx: ext_ctxt, sp: span, fields: ~[Field]) -> @ast::expr {
+pub fn mk_rec_e(cx: ext_ctxt,
+                sp: span,
+                +fields: ~[Field])
+             -> @ast::expr {
     mk_expr(cx, sp, ast::expr_rec(mk_fields(sp, fields),
                                   option::None::<@ast::expr>))
 }
-pub fn mk_struct_e(cx: ext_ctxt, sp: span, ctor_path: ~[ast::ident],
-                   fields: ~[Field]) -> @ast::expr {
+pub fn mk_struct_e(cx: ext_ctxt,
+                   sp: span,
+                   +ctor_path: ~[ast::ident],
+                   +fields: ~[Field])
+                -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-pub fn mk_global_struct_e(cx: ext_ctxt, sp: span,
-                          ctor_path: ~[ast::ident],
-                          fields: ~[Field])
+pub fn mk_global_struct_e(cx: ext_ctxt,
+                          sp: span,
+                          +ctor_path: ~[ast::ident],
+                          +fields: ~[Field])
                        -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path_global(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-pub fn mk_glob_use(cx: ext_ctxt, sp: span, path: ~[ast::ident])
-            -> @ast::view_item {
+pub fn mk_glob_use(cx: ext_ctxt,
+                   sp: span,
+                   +path: ~[ast::ident]) -> @ast::view_item {
     let glob = @codemap::spanned {
         node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()),
         span: sp,
@@ -218,8 +226,8 @@ pub fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
     @codemap::spanned { node: ast::stmt_decl(@decl, cx.next_id()), span: sp }
 }
 pub fn mk_block(cx: ext_ctxt, span: span,
-                view_items: ~[@ast::view_item],
-                stmts: ~[@ast::stmt],
+                +view_items: ~[@ast::view_item],
+                +stmts: ~[@ast::stmt],
                 expr: Option<@ast::expr>) -> @ast::expr {
     let blk = codemap::spanned {
         node: ast::blk_ {
@@ -313,7 +321,7 @@ pub fn mk_stmt(cx: ext_ctxt, span: span, expr: @ast::expr) -> @ast::stmt {
 }
 pub fn mk_ty_path(cx: ext_ctxt,
                   span: span,
-                  idents: ~[ ast::ident ])
+                  +idents: ~[ ast::ident ])
                -> @ast::Ty {
     let ty = build::mk_raw_path(span, idents);
     let ty = ast::ty_path(ty, cx.next_id());
@@ -322,7 +330,7 @@ pub fn mk_ty_path(cx: ext_ctxt,
 }
 pub fn mk_ty_path_global(cx: ext_ctxt,
                          span: span,
-                         idents: ~[ ast::ident ])
+                         +idents: ~[ ast::ident ])
                       -> @ast::Ty {
     let ty = build::mk_raw_path_global(span, idents);
     let ty = ast::ty_path(ty, cx.next_id());

trunk/src/libsyntax/ext/deriving.rs

@@ -472,8 +472,8 @@ fn call_substructure_iter_bytes_method(cx: ext_ctxt,
 
 fn variant_arg_count(cx: ext_ctxt, span: span, variant: &variant) -> uint {
     match variant.node.kind {
-        tuple_variant_kind(args) => args.len(),
-        struct_variant_kind(struct_def) => struct_def.fields.len(),
+        tuple_variant_kind(ref args) => args.len(),
+        struct_variant_kind(ref struct_def) => struct_def.fields.len(),
         enum_variant_kind(*) => {
             cx.span_bug(span, ~"variant_arg_count: enum variants deprecated")
         }

trunk/src/libsyntax/ext/env.rs

@@ -31,8 +31,8 @@ pub fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: &[ast::token_tree])
     // Option<str> rather than just an maybe-empty string.
 
     let e = match os::getenv(var) {
-      option::None => mk_uniq_str(cx, sp, ~""),
-      option::Some(ref s) => mk_uniq_str(cx, sp, (*s))
+      None => mk_uniq_str(cx, sp, ~""),
+      Some(ref s) => mk_uniq_str(cx, sp, copy *s)
     };
     MRExpr(e)
 }