De-mode vec::map, vec::eachi, vec::rev_each, vec::rev_eachi

15 files changed, 82 insertions, 78 deletions

diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 3257e54626b..85de1e1c60f 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -58,7 +58,7 @@ type path = ~[path_elt];
 /* FIXMEs that say "bad" are as per #2543 */
 fn path_to_str_with_sep(p: path, sep: ~str, itr: ident_interner) -> ~str {
     let strs = do vec::map(p) |e| {
-        match e {
+        match *e {
           path_mod(s) => *itr.get(s),
           path_name(s) => *itr.get(s)
         }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 41be872f060..b0df0ea1c8d 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -25,7 +25,7 @@ pure fn dummy_sp() -> span { return mk_sp(0u, 0u); }
 
 pure fn path_name_i(idents: ~[ident], intr: token::ident_interner) -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
-    str::connect(idents.map(|i| *intr.get(i)), ~"::")
+    str::connect(idents.map(|i| *intr.get(*i)), ~"::")
 }
 
 
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 1a8096484c2..a710b558594 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -95,14 +95,14 @@ fn attr_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
     return mitems;
 }
 
-fn desugar_doc_attr(attr: ast::attribute) -> ast::attribute {
+fn desugar_doc_attr(attr: &ast::attribute) -> ast::attribute {
     if attr.node.is_sugared_doc {
         let comment = get_meta_item_value_str(@attr.node.value).get();
         let meta = mk_name_value_item_str(~"doc",
                                      strip_doc_comment_decoration(comment));
         return mk_attr(meta);
     } else {
-        attr
+        *attr
     }
 }
 
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index 28d47087ccc..5e99314712f 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -183,7 +183,7 @@ impl ext_ctxt: ext_ctxt_helpers {
              -output: @ast::ty) -> @ast::ty {
         let args = do vec::map(input_tys) |ty| {
             {mode: ast::expl(ast::by_ref),
-             ty: ty,
+             ty: *ty,
              ident: parse::token::special_idents::invalid,
              id: self.next_id()}
         };
@@ -333,7 +333,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
                 cx.helper_path(path, ~"serialize")));
 
     let ty_args = do vec::map(path.types) |ty| {
-        let sv_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v });
+        let sv_stmts = ser_ty(cx, tps, *ty, cx.clone(s), #ast{ __v });
         let sv = cx.expr(path.span,
                          ast::expr_block(cx.blk(path.span, sv_stmts)));
         cx.at(ty.span, #ast{ |__v| $(sv) })
@@ -588,7 +588,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
         vec::append(~[{ident: cx.ident_of(~"__S"),
                       id: cx.next_id(),
                       bounds: ser_bnds}],
-                    vec::map(tps, |tp| cx.clone_ty_param(tp)));
+                    vec::map(tps, |tp| cx.clone_ty_param(*tp)));
 
     let ser_output: @ast::ty = @{id: cx.next_id(),
                                  node: ast::ty_nil,
@@ -624,7 +624,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
                 cx.helper_path(path, ~"deserialize")));
 
     let ty_args = do vec::map(path.types) |ty| {
-        let dv_expr = deser_ty(cx, tps, ty, cx.clone(d));
+        let dv_expr = deser_ty(cx, tps, *ty, cx.clone(d));
         cx.lambda(cx.expr_blk(dv_expr))
     };
 
@@ -795,7 +795,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
                       id: cx.next_id(),
                       bounds: deser_bnds}],
                     vec::map(tps, |tp| {
-                        let cloned = cx.clone_ty_param(tp);
+                        let cloned = cx.clone_ty_param(*tp);
                         {bounds: @(vec::append(*cloned.bounds,
                                                ~[ast::bound_copy])),
                          .. cloned}
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 8143213dbf8..a3ab35d77f0 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -320,7 +320,7 @@ fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree])
                           argument_gram).get(arg_nm) {
           @matched_seq(s, _) => {
             do s.map() |lf| {
-                match lf {
+                match *lf {
                   @matched_nonterminal(parse::token::nt_expr(arg)) =>
                     arg, /* whew! list of exprs, here we come! */
                   _ => fail ~"badly-structured parse result"
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index 01046dded26..1b25ea73f07 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -265,7 +265,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
     fn variant(name: ident,
                span: span,
                +tys: ~[@ast::ty]) -> ast::variant {
-        let args = tys.map(|ty| {ty: ty, id: self.next_id()});
+        let args = tys.map(|ty| {ty: *ty, id: self.next_id()});
 
         {node: {name: name,
                 attrs: ~[],
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 913d69d391f..11250cfbf38 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -91,7 +91,7 @@ impl message: gen_send {
                          this.proto.name,
                          self.name(),
                          str::connect(vec::append_one(
-                           arg_names.map(|x| ~"move " + cx.str_of(x)),
+                           arg_names.map(|x| ~"move " + cx.str_of(*x)),
                              ~"move s"), ~", "));
 
             if !try {
@@ -144,7 +144,7 @@ impl message: gen_send {
                     ~""
                 }
                 else {
-                    ~"(" + str::connect(arg_names.map(|x| ~"move " + x),
+                    ~"(" + str::connect(arg_names.map(|x| ~"move " + *x),
                                         ~", ") + ~")"
                 };
 
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
index 9656a63cb0b..5ddc492d0fb 100644
--- a/src/libsyntax/ext/pipes/proto.rs
+++ b/src/libsyntax/ext/pipes/proto.rs
@@ -224,10 +224,10 @@ fn visit<Tproto, Tstate, Tmessage, V: visitor<Tproto, Tstate, Tmessage>>(
     // the copy keywords prevent recursive use of dvec
     let states = do (copy proto.states).map_to_vec |s| {
         let messages = do (copy s.messages).map_to_vec |m| {
-            let message(name, span, tys, this, next) = m;
+            let message(name, span, tys, this, next) = *m;
             visitor.visit_message(name, span, tys, this, next)
         };
-        visitor.visit_state(s, messages)
+        visitor.visit_state(*s, messages)
     };
     visitor.visit_proto(proto, states)
 }
diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs
index 83899b58d66..115a640bda8 100644
--- a/src/libsyntax/ext/qquote.rs
+++ b/src/libsyntax/ext/qquote.rs
@@ -28,7 +28,7 @@ enum fragment {
 }
 
 fn ids_ext(cx: ext_ctxt, strs: ~[~str]) -> ~[ast::ident] {
-    strs.map(|str| cx.parse_sess().interner.intern(@str))
+    strs.map(|str| cx.parse_sess().interner.intern(@*str))
 }
 fn id_ext(cx: ext_ctxt, str: ~str) -> ast::ident {
     cx.parse_sess().interner.intern(@str)
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index c9385b0c35c..8df57144c07 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -262,11 +262,11 @@ fn wrong_occurs(cx: ext_ctxt, l: ident, l_c: uint, r: ident, r_c: uint)
 
 /* handle sequences (anywhere in the AST) of exprs, either real or ...ed */
 fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
-                    recur: fn@(&&@expr) -> @expr,
+                    recur: fn@(&&v: @expr) -> @expr,
                     exprs: ~[@expr]) -> ~[@expr] {
     match elts_to_ell(cx, exprs) {
       {pre: pre, rep: repeat_me_maybe, post: post} => {
-        let mut res = vec::map(pre, recur);
+        let mut res = vec::map(pre, |x| recur(*x));
         match repeat_me_maybe {
           None => (),
           Some(repeat_me) => {
@@ -314,7 +314,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
             }
           }
         }
-        res = vec::append(res, vec::map(post, recur));
+        res = vec::append(res, vec::map(post, |x| recur(*x)));
         return res;
       }
     }
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index b6f740603fc..9b41d90e6d0 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -50,7 +50,8 @@ fn expand_mod(cx: ext_ctxt, sp: span, arg: ast::mac_arg, _body: ast::mac_body)
     -> @ast::expr {
     get_mac_args(cx, sp, arg, 0u, option::Some(0u), ~"file");
     return mk_uniq_str(cx, sp,
-                    str::connect(cx.mod_path().map(|x| cx.str_of(x)), ~"::"));
+                       str::connect(cx.mod_path().map(
+                           |x| cx.str_of(*x)), ~"::"));
 }
 
 fn expand_include(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
@@ -88,8 +89,8 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
 
     match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
       result::Ok(src) => {
-        let u8_exprs = vec::map(src, |char: u8| {
-            mk_u8(cx, sp, char)
+        let u8_exprs = vec::map(src, |char| {
+            mk_u8(cx, sp, *char)
         });
         return mk_base_vec_e(cx, sp, u8_exprs);
       }
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index ebb62293cc5..52369ad7207 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -72,7 +72,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
         let itr = cx.parse_sess().interner;
 
         for lhses.eachi() |i, lhs| { // try each arm's matchers
-            match lhs {
+            match *lhs {
               @matched_nonterminal(nt_matchers(mtcs)) => {
                 // `none` is because we're not interpolating
                 let arg_rdr = new_tt_reader(s_d, itr, None, arg) as reader;
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index c6499e025da..7fb910cd4b6 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -29,7 +29,7 @@ type tt_reader = @{
     mut cur: tt_frame,
     /* for MBE-style macro transcription */
     interpolations: std::map::HashMap<ident, @named_match>,
-    mut repeat_idx: ~[mut uint],
+    mut repeat_idx: ~[uint],
     mut repeat_len: ~[uint],
     /* cached: */
     mut cur_tok: token,
@@ -50,7 +50,8 @@ fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
                 None => std::map::HashMap::<uint,@named_match>(),
                 Some(x) => x
               },
-              mut repeat_idx: ~[mut], mut repeat_len: ~[],
+              mut repeat_idx: ~[],
+              mut repeat_len: ~[],
               /* dummy values, never read: */
               mut cur_tok: EOF,
               mut cur_span: ast_util::mk_sp(0u,0u)
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index c7ce86921f6..f9b1959f051 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -85,7 +85,7 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
                 meta_list(id, mis) => {
                   let fold_meta_item = |x|fold_meta_item_(x, fld);
                   meta_list(/* FIXME: (#2543) */ copy id,
-                            vec::map(mis, fold_meta_item))
+                            vec::map(mis, |e| fold_meta_item(*e)))
                 }
                 meta_name_value(id, s) => {
                   meta_name_value(id, /* FIXME (#2543) */ copy s)
@@ -125,7 +125,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
 }
 
 fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
-    return {inputs: vec::map(decl.inputs, |x| fold_arg_(x, fld) ),
+    return {inputs: vec::map(decl.inputs, |x| fold_arg_(*x, fld) ),
          output: fld.fold_ty(decl.output),
          cf: decl.cf}
 }
@@ -140,11 +140,11 @@ fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
 fn fold_ty_param(tp: ty_param, fld: ast_fold) -> ty_param {
     {ident: /* FIXME (#2543) */ copy tp.ident,
      id: fld.new_id(tp.id),
-     bounds: @vec::map(*tp.bounds, |x| fold_ty_param_bound(x, fld) )}
+     bounds: @vec::map(*tp.bounds, |x| fold_ty_param_bound(*x, fld) )}
 }
 
 fn fold_ty_params(tps: ~[ty_param], fld: ast_fold) -> ~[ty_param] {
-    vec::map(tps, |x| fold_ty_param(x, fld) )
+    vec::map(tps, |x| fold_ty_param(*x, fld) )
 }
 
 fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
@@ -152,10 +152,10 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
     let fold_attribute = |x| fold_attribute_(x, fld);
 
     return {
-        directives: vec::map(c.directives, |x| fld.fold_crate_directive(x)),
+        directives: vec::map(c.directives, |x| fld.fold_crate_directive(*x)),
         module: fld.fold_mod(c.module),
-        attrs: vec::map(c.attrs, fold_attribute),
-        config: vec::map(c.config, fold_meta_item)
+        attrs: vec::map(c.attrs, |x| fold_attribute(*x)),
+        config: vec::map(c.config, |x| fold_meta_item(*x))
     };
 }
 
@@ -167,7 +167,7 @@ fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) ->
           }
           cdir_dir_mod(id, cds, attrs) => {
             cdir_dir_mod(fld.fold_ident(id),
-                         vec::map(cds, |x| fld.fold_crate_directive(x)),
+                         vec::map(cds, |x| fld.fold_crate_directive(*x)),
                          /* FIXME (#2543) */ copy attrs)
           }
           cdir_view_item(vi) => cdir_view_item(fld.fold_view_item(vi)),
@@ -186,15 +186,16 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
     let fold_attribute = |x| fold_attribute_(x, fld);
 
     return @{ident: fld.fold_ident(ni.ident),
-          attrs: vec::map(ni.attrs, fold_attribute),
+          attrs: vec::map(ni.attrs, |x| fold_attribute(*x)),
           node:
               match ni.node {
                 foreign_item_fn(fdec, purity, typms) => {
-                  foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg),
-                                   output: fld.fold_ty(fdec.output),
-                                   cf: fdec.cf},
-                                  purity,
-                                  fold_ty_params(typms, fld))
+                  foreign_item_fn(
+                      {inputs: vec::map(fdec.inputs, |a| fold_arg(*a)),
+                       output: fld.fold_ty(fdec.output),
+                       cf: fdec.cf},
+                      purity,
+                      fold_ty_params(typms, fld))
                 }
                 foreign_item_const(t) => {
                   foreign_item_const(fld.fold_ty(t))
@@ -208,7 +209,7 @@ fn noop_fold_item(&&i: @item, fld: ast_fold) -> Option<@item> {
     let fold_attribute = |x| fold_attribute_(x, fld);
 
     return Some(@{ident: fld.fold_ident(i.ident),
-               attrs: vec::map(i.attrs, fold_attribute),
+               attrs: vec::map(i.attrs, |e| fold_attribute(*e)),
                id: fld.new_id(i.id),
                node: fld.fold_item_underscore(i.node),
                vis: i.vis,
@@ -239,7 +240,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           item_enum(enum_definition, typms) => {
             item_enum(ast::enum_def({
                 variants: vec::map(enum_definition.variants,
-                                   |x| fld.fold_variant(x)),
+                                   |x| fld.fold_variant(*x)),
                 common: option::map(enum_definition.common,
                                     |x| fold_struct_def(x, fld))
             }), fold_ty_params(typms, fld))
@@ -252,11 +253,11 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
               item_impl(fold_ty_params(tps, fld),
                         ifce.map(|p| fold_trait_ref(p, fld)),
                         fld.fold_ty(ty),
-                        vec::map(methods, |x| fld.fold_method(x)))
+                        vec::map(methods, |x| fld.fold_method(*x)))
           }
           item_trait(tps, traits, methods) => {
             item_trait(fold_ty_params(tps, fld),
-                       vec::map(traits, |p| fold_trait_ref(p, fld)),
+                       vec::map(traits, |p| fold_trait_ref(*p, fld)),
                        /* FIXME (#2543) */ copy methods)
           }
       item_mac(m) => {
@@ -292,9 +293,9 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
                 id: dtor_id,.. dtor.node},
             .. dtor}};
     return @{
-        traits: vec::map(struct_def.traits, |p| fold_trait_ref(p, fld)),
-        fields: vec::map(struct_def.fields, |f| fold_struct_field(f, fld)),
-        methods: vec::map(struct_def.methods, |m| fld.fold_method(m)),
+        traits: vec::map(struct_def.traits, |p| fold_trait_ref(*p, fld)),
+        fields: vec::map(struct_def.fields, |f| fold_struct_field(*f, fld)),
+        methods: vec::map(struct_def.methods, |m| fld.fold_method(*m)),
         ctor: resulting_optional_constructor,
         dtor: dtor
     };
@@ -328,8 +329,8 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
 
 
 fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
-    return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(x)),
-         stmts: vec::map(b.stmts, |x| fld.fold_stmt(x)),
+    return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(*x)),
+         stmts: vec::map(b.stmts, |x| fld.fold_stmt(*x)),
          expr: option::map(b.expr, |x| fld.fold_expr(x)),
          id: fld.new_id(b.id),
          rules: b.rules};
@@ -344,7 +345,7 @@ fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
 }
 
 fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
-    return {pats: vec::map(a.pats, |x| fld.fold_pat(x)),
+    return {pats: vec::map(a.pats, |x| fld.fold_pat(*x)),
          guard: option::map(a.guard, |x| fld.fold_expr(x)),
          body: fld.fold_block(a.body)};
 }
@@ -360,7 +361,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
           pat_lit(e) => pat_lit(fld.fold_expr(e)),
           pat_enum(pth, pats) => {
               pat_enum(fld.fold_path(pth), option::map(pats,
-                       |pats| vec::map(pats, |x| fld.fold_pat(x))))
+                       |pats| vec::map(pats, |x| fld.fold_pat(*x))))
           }
           pat_rec(fields, etc) => {
             let mut fs = ~[];
@@ -381,7 +382,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
             }
             pat_struct(pth_, fs, etc)
           }
-          pat_tup(elts) => pat_tup(vec::map(elts, |x| fld.fold_pat(x))),
+          pat_tup(elts) => pat_tup(vec::map(elts, |x| fld.fold_pat(*x))),
           pat_box(inner) => pat_box(fld.fold_pat(inner)),
           pat_uniq(inner) => pat_uniq(fld.fold_pat(inner)),
           pat_region(inner) => pat_region(fld.fold_pat(inner)),
@@ -393,7 +394,7 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
 
 fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
     match d {
-      decl_local(ls) => decl_local(vec::map(ls, |x| fld.fold_local(x))),
+      decl_local(ls) => decl_local(vec::map(ls, |x| fld.fold_local(*x))),
       decl_item(it) => match fld.fold_item(it) {
         Some(it_folded) => decl_item(it_folded),
         None => decl_local(~[])
@@ -431,10 +432,10 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_repeat(expr, count, mutt) =>
             expr_repeat(fld.fold_expr(expr), fld.fold_expr(count), mutt),
           expr_rec(fields, maybe_expr) => {
-            expr_rec(vec::map(fields, fold_field),
+            expr_rec(vec::map(fields, |x| fold_field(*x)),
                      option::map(maybe_expr, |x| fld.fold_expr(x)))
           }
-          expr_tup(elts) => expr_tup(vec::map(elts, |x| fld.fold_expr(x))),
+          expr_tup(elts) => expr_tup(vec::map(elts, |x| fld.fold_expr(*x))),
           expr_call(f, args, blk) => {
             expr_call(fld.fold_expr(f),
                       fld.map_exprs(|x| fld.fold_expr(x), args),
@@ -462,20 +463,20 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           }
           expr_match(expr, arms) => {
             expr_match(fld.fold_expr(expr),
-                     vec::map(arms, |x| fld.fold_arm(x)))
+                     vec::map(arms, |x| fld.fold_arm(*x)))
           }
           expr_fn(proto, decl, body, captures) => {
             expr_fn(proto, fold_fn_decl(decl, fld),
                     fld.fold_block(body),
                     @((*captures).map(|cap_item| {
-                        @({id: fld.new_id((*cap_item).id),
-                           .. *cap_item})})))
+                        @({id: fld.new_id(cap_item.id),
+                           ..**cap_item})})))
           }
           expr_fn_block(decl, body, captures) => {
             expr_fn_block(fold_fn_decl(decl, fld), fld.fold_block(body),
                           @((*captures).map(|cap_item| {
-                              @({id: fld.new_id((*cap_item).id),
-                                 .. *cap_item})})))
+                              @({id: fld.new_id(cap_item.id),
+                                 ..**cap_item})})))
           }
           expr_block(blk) => expr_block(fld.fold_block(blk)),
           expr_move(el, er) => {
@@ -494,7 +495,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           }
           expr_field(el, id, tys) => {
             expr_field(fld.fold_expr(el), fld.fold_ident(id),
-                       vec::map(tys, |x| fld.fold_ty(x)))
+                       vec::map(tys, |x| fld.fold_ty(*x)))
           }
           expr_index(el, er) => {
             expr_index(fld.fold_expr(el), fld.fold_expr(er))
@@ -512,7 +513,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
           expr_mac(mac) => expr_mac(fold_mac(mac)),
           expr_struct(path, fields, maybe_expr) => {
             expr_struct(fld.fold_path(path),
-                        vec::map(fields, fold_field),
+                        vec::map(fields, |x| fold_field(*x)),
                         option::map(maybe_expr, |x| fld.fold_expr(x)))
           }
         }
@@ -535,13 +536,13 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
       ty_vec(mt) => ty_vec(fold_mt(mt, fld)),
       ty_ptr(mt) => ty_ptr(fold_mt(mt, fld)),
       ty_rptr(region, mt) => ty_rptr(region, fold_mt(mt, fld)),
-      ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(f, fld))),
+      ty_rec(fields) => ty_rec(vec::map(fields, |f| fold_field(*f, fld))),
       ty_fn(proto, purity, bounds, decl) =>
         ty_fn(proto, purity,
               @vec::map(*bounds,
-                        |x| fold_ty_param_bound(x, fld)),
+                        |x| fold_ty_param_bound(*x, fld)),
               fold_fn_decl(decl, fld)),
-      ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(ty))),
+      ty_tup(tys) => ty_tup(vec::map(tys, |ty| fld.fold_ty(*ty))),
       ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)),
       ty_fixed_length(t, vs) => ty_fixed_length(fld.fold_ty(t), vs),
       ty_mac(mac) => ty_mac(fold_mac(mac))
@@ -550,14 +551,14 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
 
 // ...nor do modules
 fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod {
-    return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(x)),
+    return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)),
          items: vec::filter_map(m.items, |x| fld.fold_item(x))};
 }
 
 fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod {
     return {sort: nm.sort,
-         view_items: vec::map(nm.view_items, |x| fld.fold_view_item(x)),
-         items: vec::map(nm.items, |x| fld.fold_foreign_item(x))}
+         view_items: vec::map(nm.view_items, |x| fld.fold_view_item(*x)),
+         items: vec::map(nm.items, |x| fld.fold_foreign_item(*x))}
 }
 
 fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
@@ -570,7 +571,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     match v.kind {
         tuple_variant_kind(variant_args) =>
             kind = tuple_variant_kind(vec::map(variant_args,
-                                               fold_variant_arg)),
+                                               |x| fold_variant_arg(*x))),
         struct_variant_kind(struct_def) => {
             let dtor = do option::map(struct_def.dtor) |dtor| {
                 let dtor_body = fld.fold_block(dtor.node.body);
@@ -581,8 +582,9 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
             kind = struct_variant_kind(@{
                 traits: ~[],
                 fields: vec::map(struct_def.fields,
-                                 |f| fld.fold_struct_field(f)),
-                methods: vec::map(struct_def.methods, |m| fld.fold_method(m)),
+                                 |f| fld.fold_struct_field(*f)),
+                methods: vec::map(struct_def.methods,
+                                  |m| fld.fold_method(*m)),
                 ctor: None,
                 dtor: dtor
             })
@@ -590,7 +592,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
 
         enum_variant_kind(enum_definition) => {
             let variants = vec::map(enum_definition.variants,
-                                    |x| fld.fold_variant(x));
+                                    |x| fld.fold_variant(*x));
             let common = option::map(enum_definition.common,
                                      |x| fold_struct_def(x, fld));
             kind = enum_variant_kind(ast::enum_def({ variants: variants,
@@ -599,7 +601,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     }
 
     let fold_attribute = |x| fold_attribute_(x, fld);
-    let attrs = vec::map(v.attrs, fold_attribute);
+    let attrs = vec::map(v.attrs, |x| fold_attribute(*x));
 
     let de = match v.disr_expr {
       Some(e) => Some(fld.fold_expr(e)),
@@ -619,9 +621,9 @@ fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident {
 
 fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
     return {span: fld.new_span(p.span), global: p.global,
-         idents: vec::map(p.idents, |x| fld.fold_ident(x)),
+         idents: vec::map(p.idents, |x| fld.fold_ident(*x)),
          rp: p.rp,
-         types: vec::map(p.types, |x| fld.fold_ty(x))};
+         types: vec::map(p.types, |x| fld.fold_ty(*x))};
 }
 
 fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
@@ -642,7 +644,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
 /* temporarily eta-expand because of a compiler bug with using `fn<T>` as a
    value */
 fn noop_map_exprs(f: fn@(&&@expr) -> @expr, es: ~[@expr]) -> ~[@expr] {
-    return vec::map(es, f);
+    return vec::map(es, |x| f(*x));
 }
 
 fn noop_id(i: node_id) -> node_id { return i; }
@@ -692,7 +694,7 @@ impl ast_fold_precursor: ast_fold {
        @view_item {
         return @{node: self.fold_view_item(x.node, self as ast_fold),
               attrs: vec::map(x.attrs, |a|
-                  fold_attribute_(a, self as ast_fold)),
+                  fold_attribute_(*a, self as ast_fold)),
               vis: x.vis,
               span: self.new_span(x.span)};
     }
@@ -784,7 +786,7 @@ impl ast_fold_precursor: ast_fold {
 
 impl ast_fold {
     fn fold_attributes(attrs: ~[attribute]) -> ~[attribute] {
-        attrs.map(|x| fold_attribute_(x, self))
+        attrs.map(|x| fold_attribute_(*x, self))
     }
 }
 
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 7f1ec109370..471a800b382 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -89,7 +89,7 @@ fn strip_doc_comment_decoration(comment: ~str) -> ~str {
         }
 
         return do lines.map |line| {
-            let chars = str::chars(line);
+            let chars = str::chars(*line);
             if i > chars.len() {
                 ~""
             } else {