auto merge of #17268 : aturon/rust/mut-conventions, r=alexcrichton

As per [RFC 52](https://github.com/rust-lang/rfcs/blob/master/active/0052-ownership-variants.md), use `_mut` suffixes to mark mutable variants, and `into_iter` for moving iterators. Additional details and motivation in the RFC.

Note that the iterator *type* names are not changed by this RFC; those are awaiting a separate RFC for standardization.

Closes #13660
Closes #16810

[breaking-change]

17 files changed, 80 insertions, 74 deletions

diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs
index 20594a42848..ed0b8700bf3 100644
--- a/src/libsyntax/ast_map/mod.rs
+++ b/src/libsyntax/ast_map/mod.rs
@@ -417,7 +417,7 @@ impl<'ast> Map<'ast> {
 
     fn path_to_str_with_ident(&self, id: NodeId, i: Ident) -> String {
         self.with_path(id, |path| {
-            path_to_string(path.chain(Some(PathName(i.name)).move_iter()))
+            path_to_string(path.chain(Some(PathName(i.name)).into_iter()))
         })
     }
 
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 80e4d148bde..ace1e1245c7 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -245,14 +245,14 @@ pub fn last_meta_item_value_str_by_name(items: &[P<MetaItem>], name: &str)
 pub fn sort_meta_items(items: Vec<P<MetaItem>>) -> Vec<P<MetaItem>> {
     // This is sort of stupid here, but we need to sort by
     // human-readable strings.
-    let mut v = items.move_iter()
+    let mut v = items.into_iter()
         .map(|mi| (mi.name(), mi))
         .collect::<Vec<(InternedString, P<MetaItem>)>>();
 
     v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
 
     // There doesn't seem to be a more optimal way to do this
-    v.move_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
+    v.into_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
         Spanned {
             node: match node {
                 MetaList(n, mis) => MetaList(n, sort_meta_items(mis)),
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 6e25b6b73ad..773daa4a4c5 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -712,7 +712,7 @@ impl SyntaxEnv {
     }
 
     fn find_escape_frame<'a>(&'a mut self) -> &'a mut MapChainFrame {
-        for (i, frame) in self.chain.mut_iter().enumerate().rev() {
+        for (i, frame) in self.chain.iter_mut().enumerate().rev() {
             if !frame.info.macros_escape || i == 0 {
                 return frame
             }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index eda373c4fb8..7b2613d4e8b 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -301,7 +301,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                 types: Vec<P<ast::Ty>> )
                 -> ast::Path {
         let last_identifier = idents.pop().unwrap();
-        let mut segments: Vec<ast::PathSegment> = idents.move_iter()
+        let mut segments: Vec<ast::PathSegment> = idents.into_iter()
                                                       .map(|ident| {
             ast::PathSegment {
                 identifier: ident,
@@ -969,7 +969,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant {
-        let args = tys.move_iter().map(|ty| {
+        let args = tys.into_iter().map(|ty| {
             ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID }
         }).collect();
 
diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs
index 455148bfedd..cd3e247a806 100644
--- a/src/libsyntax/ext/concat.rs
+++ b/src/libsyntax/ext/concat.rs
@@ -25,7 +25,7 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
         None => return base::DummyResult::expr(sp)
     };
     let mut accumulator = String::new();
-    for e in es.move_iter() {
+    for e in es.into_iter() {
         match e.node {
             ast::ExprLit(ref lit) => {
                 match lit.node {
diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs
index 98c8885f7fa..ecee2008254 100644
--- a/src/libsyntax/ext/deriving/cmp/totaleq.rs
+++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs
@@ -26,7 +26,7 @@ pub fn expand_deriving_totaleq(cx: &mut ExtCtxt,
         cs_same_method(|cx, span, exprs| {
             // create `a.<method>(); b.<method>(); c.<method>(); ...`
             // (where method is `assert_receiver_is_total_eq`)
-            let stmts = exprs.move_iter().map(|e| cx.stmt_expr(e)).collect();
+            let stmts = exprs.into_iter().map(|e| cx.stmt_expr(e)).collect();
             let block = cx.block(span, stmts, None);
             cx.expr_block(block)
         },
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
index 53af5a86ed2..ff249495bd7 100644
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@@ -468,7 +468,7 @@ impl<'a> TraitDef<'a> {
             ast::ItemImpl(trait_generics,
                           opt_trait_ref,
                           self_type,
-                          methods.move_iter()
+                          methods.into_iter()
                                  .map(|method| {
                                      ast::MethodImplItem(method)
                                  }).collect()))
@@ -666,10 +666,10 @@ impl<'a> MethodDef<'a> {
             _ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable, special_idents::self_))
         };
         let args = {
-            let args = arg_types.move_iter().map(|(name, ty)| {
+            let args = arg_types.into_iter().map(|(name, ty)| {
                     cx.arg(trait_.span, name, ty)
                 });
-            self_arg.move_iter().chain(args).collect()
+            self_arg.into_iter().chain(args).collect()
         };
 
         let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
@@ -741,7 +741,7 @@ impl<'a> MethodDef<'a> {
 
         // transpose raw_fields
         let fields = if raw_fields.len() > 0 {
-            let mut raw_fields = raw_fields.move_iter().map(|v| v.move_iter());
+            let mut raw_fields = raw_fields.into_iter().map(|v| v.into_iter());
             let first_field = raw_fields.next().unwrap();
             let mut other_fields: Vec<vec::MoveItems<(Span, Option<Ident>, P<Expr>)>>
                 = raw_fields.collect();
@@ -750,7 +750,7 @@ impl<'a> MethodDef<'a> {
                     span: span,
                     name: opt_id,
                     self_: field,
-                    other: other_fields.mut_iter().map(|l| {
+                    other: other_fields.iter_mut().map(|l| {
                         match l.next().unwrap() {
                             (_, _, ex) => ex
                         }
@@ -953,7 +953,7 @@ impl<'a> MethodDef<'a> {
 
                 // The transposition is driven by walking across the
                 // arg fields of the variant for the first self pat.
-                let field_tuples = first_self_pat_idents.move_iter().enumerate()
+                let field_tuples = first_self_pat_idents.into_iter().enumerate()
                     // For each arg field of self, pull out its getter expr ...
                     .map(|(field_index, (sp, opt_ident, self_getter_expr))| {
                         // ... but FieldInfo also wants getter expr
@@ -1264,7 +1264,7 @@ impl<'a> TraitDef<'a> {
         // struct_type is definitely not Unknown, since struct_def.fields
         // must be nonempty to reach here
         let pattern = if struct_type == Record {
-            let field_pats = subpats.move_iter().zip(ident_expr.iter()).map(|(pat, &(_, id, _))| {
+            let field_pats = subpats.into_iter().zip(ident_expr.iter()).map(|(pat, &(_, id, _))| {
                 // id is guaranteed to be Some
                 ast::FieldPat { ident: id.unwrap(), pat: pat }
             }).collect();
@@ -1418,11 +1418,11 @@ pub fn cs_same_method_fold(use_foldl: bool,
     cs_same_method(
         |cx, span, vals| {
             if use_foldl {
-                vals.move_iter().fold(base.clone(), |old, new| {
+                vals.into_iter().fold(base.clone(), |old, new| {
                     f(cx, span, old, new)
                 })
             } else {
-                vals.move_iter().rev().fold(base.clone(), |old, new| {
+                vals.into_iter().rev().fold(base.clone(), |old, new| {
                     f(cx, span, old, new)
                 })
             }
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index 69574ee6696..87e257c52cd 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -67,7 +67,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
             return DummyResult::expr(sp);
         }
         None => return DummyResult::expr(sp),
-        Some(exprs) => exprs.move_iter()
+        Some(exprs) => exprs.into_iter()
     };
 
     let var = match expr_to_string(cx,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 310f7c4f303..4ff9912645a 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -271,8 +271,8 @@ pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
                     let mut items: SmallVector<P<ast::Item>> = SmallVector::zero();
                     dec.expand(fld.cx, attr.span, &*attr.node.value, &*it,
                                |item| items.push(item));
-                    decorator_items.extend(items.move_iter()
-                        .flat_map(|item| expand_item(item, fld).move_iter()));
+                    decorator_items.extend(items.into_iter()
+                        .flat_map(|item| expand_item(item, fld).into_iter()));
 
                     fld.cx.bt_pop();
                 }
@@ -485,9 +485,9 @@ pub fn expand_item_mac(it: P<ast::Item>, fld: &mut MacroExpander)
             SmallVector::zero()
         }
         Right(Some(items)) => {
-            items.move_iter()
+            items.into_iter()
                 .map(|i| mark_item(i, fm))
-                .flat_map(|i| fld.fold_item(i).move_iter())
+                .flat_map(|i| fld.fold_item(i).into_iter())
                 .collect()
         }
         Right(None) => {
@@ -525,7 +525,7 @@ fn expand_stmt(s: Stmt, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
     fld.cx.bt_pop();
 
     if semi {
-        fully_expanded.move_iter().map(|s| s.map(|Spanned {node, span}| {
+        fully_expanded.into_iter().map(|s| s.map(|Spanned {node, span}| {
             Spanned {
                 node: match node {
                     StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
@@ -620,7 +620,7 @@ fn expand_arm(arm: ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
     // all of the pats must have the same set of bindings, so use the
     // first one to extract them and generate new names:
     let idents = pattern_bindings(&**expanded_pats.get(0));
-    let new_renames = idents.move_iter().map(|id| (id, fresh_name(&id))).collect();
+    let new_renames = idents.into_iter().map(|id| (id, fresh_name(&id))).collect();
     // apply the renaming, but only to the PatIdents:
     let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
     let rewritten_pats = expanded_pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
@@ -687,8 +687,8 @@ pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
 // expand the elements of a block.
 pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
     b.map(|Block {id, view_items, stmts, expr, rules, span}| {
-        let new_view_items = view_items.move_iter().map(|x| fld.fold_view_item(x)).collect();
-        let new_stmts = stmts.move_iter().flat_map(|x| {
+        let new_view_items = view_items.into_iter().map(|x| fld.fold_view_item(x)).collect();
+        let new_stmts = stmts.into_iter().flat_map(|x| {
             // perform all pending renames
             let renamed_stmt = {
                 let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
@@ -696,7 +696,7 @@ pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
                 rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
             };
             // expand macros in the statement
-            fld.fold_stmt(renamed_stmt).move_iter()
+            fld.fold_stmt(renamed_stmt).into_iter()
         }).collect();
         let new_expr = expr.map(|x| {
             let expr = {
@@ -897,7 +897,7 @@ fn expand_method(m: P<ast::Method>, fld: &mut MacroExpander) -> SmallVector<P<as
             };
 
             // expand again if necessary
-            new_methods.move_iter().flat_map(|m| fld.fold_method(m).move_iter()).collect()
+            new_methods.into_iter().flat_map(|m| fld.fold_method(m).into_iter()).collect()
         }
     })
 }
@@ -994,11 +994,11 @@ pub fn expand_crate(parse_sess: &parse::ParseSess,
         cx: &mut cx,
     };
 
-    for ExportedMacros { crate_name, macros } in imported_macros.move_iter() {
+    for ExportedMacros { crate_name, macros } in imported_macros.into_iter() {
         let name = format!("<{} macros>", token::get_ident(crate_name))
             .into_string();
 
-        for source in macros.move_iter() {
+        for source in macros.into_iter() {
             let item = parse::parse_item_from_source_str(name.clone(),
                                                          source,
                                                          expander.cx.cfg(),
@@ -1008,7 +1008,7 @@ pub fn expand_crate(parse_sess: &parse::ParseSess,
         }
     }
 
-    for (name, extension) in user_exts.move_iter() {
+    for (name, extension) in user_exts.into_iter() {
         expander.cx.syntax_env.insert(name, extension);
     }
 
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 271a5137bbf..26586684309 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -500,7 +500,7 @@ impl<'a, 'b> Context<'a, 'b> {
         let mut heads = Vec::new();
 
         // First, declare all of our methods that are statics
-        for method in self.method_statics.move_iter() {
+        for method in self.method_statics.into_iter() {
             let decl = respan(self.fmtsp, ast::DeclItem(method));
             lets.push(P(respan(self.fmtsp,
                                ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID))));
@@ -543,7 +543,7 @@ impl<'a, 'b> Context<'a, 'b> {
         // format! string are shoved into locals. Furthermore, we shove the address
         // of each variable because we don't want to move out of the arguments
         // passed to this function.
-        for (i, e) in self.args.move_iter().enumerate() {
+        for (i, e) in self.args.into_iter().enumerate() {
             let arg_ty = match self.arg_types.get(i).as_ref() {
                 Some(ty) => ty,
                 None => continue // error already generated
@@ -577,8 +577,8 @@ impl<'a, 'b> Context<'a, 'b> {
         // Now create a vector containing all the arguments
         let slicename = self.ecx.ident_of("__args_vec");
         {
-            let args = names.move_iter().map(|a| a.unwrap());
-            let mut args = locals.move_iter().chain(args);
+            let args = names.into_iter().map(|a| a.unwrap());
+            let mut args = locals.into_iter().chain(args);
             let args = self.ecx.expr_vec_slice(self.fmtsp, args.collect());
             lets.push(self.ecx.stmt_let(self.fmtsp, false, slicename, args));
         }
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 6f13a2e6a51..aa2a23dd276 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -54,7 +54,7 @@ pub mod rt {
 
     impl<T: ToTokens> ToTokens for Vec<T> {
         fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
-            let a = self.iter().flat_map(|t| t.to_tokens(cx).move_iter());
+            let a = self.iter().flat_map(|t| t.to_tokens(cx).into_iter());
             FromIterator::from_iter(a)
         }
     }
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 3006bcaf6f8..090b39eee47 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -366,7 +366,7 @@ pub fn parse(sess: &ParseSess,
         if token_name_eq(&tok, &EOF) {
             if eof_eis.len() == 1u {
                 let mut v = Vec::new();
-                for dv in eof_eis.get_mut(0).matches.mut_iter() {
+                for dv in eof_eis.get_mut(0).matches.iter_mut() {
                     v.push(dv.pop().unwrap());
                 }
                 return Success(nameize(sess, ms, v.as_slice()));
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 726a7315f69..1b9f6f16542 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -164,7 +164,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
         /* done with this set; pop or repeat? */
         if should_pop {
             let prev = r.stack.pop().unwrap();
-            match r.stack.mut_last() {
+            match r.stack.last_mut() {
                 None => {
                     r.cur_tok = EOF;
                     return ret_val;
@@ -178,8 +178,8 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                 r.repeat_len.pop();
             }
         } else { /* repeat */
-            *r.repeat_idx.mut_last().unwrap() += 1u;
-            r.stack.mut_last().unwrap().idx = 0;
+            *r.repeat_idx.last_mut().unwrap() += 1u;
+            r.stack.last_mut().unwrap().idx = 0;
             match r.stack.last().unwrap().sep.clone() {
                 Some(tk) => {
                     r.cur_tok = tk; /* repeat same span, I guess */
@@ -209,7 +209,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
             TTTok(sp, tok) => {
                 r.cur_span = sp;
                 r.cur_tok = tok;
-                r.stack.mut_last().unwrap().idx += 1;
+                r.stack.last_mut().unwrap().idx += 1;
                 return ret_val;
             }
             TTSeq(sp, tts, sep, zerok) => {
@@ -234,7 +234,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                                                      "this must repeat at least once");
                             }
 
-                            r.stack.mut_last().unwrap().idx += 1;
+                            r.stack.last_mut().unwrap().idx += 1;
                             return tt_next_token(r);
                         }
                         r.repeat_len.push(len);
@@ -250,7 +250,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
             }
             // FIXME #2887: think about span stuff here
             TTNonterminal(sp, ident) => {
-                r.stack.mut_last().unwrap().idx += 1;
+                r.stack.last_mut().unwrap().idx += 1;
                 match *lookup_cur_matched(r, ident) {
                     /* sidestep the interpolation tricks for ident because
                        (a) idents can be in lots of places, so it'd be a pain
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index e63954c3680..4806c5fa7c0 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -37,7 +37,7 @@ pub trait MoveMap<T> {
 impl<T> MoveMap<T> for Vec<T> {
     fn move_map(mut self, f: |T| -> T) -> Vec<T> {
         use std::{mem, ptr};
-        for p in self.mut_iter() {
+        for p in self.iter_mut() {
             unsafe {
                 // FIXME(#5016) this shouldn't need to zero to be safe.
                 mem::move_val_init(p, f(ptr::read_and_zero(p)));
@@ -351,7 +351,7 @@ pub fn noop_fold_decl<T: Folder>(d: P<Decl>, fld: &mut T) -> SmallVector<P<Decl>
             node: DeclLocal(fld.fold_local(l)),
             span: fld.new_span(span)
         })),
-        DeclItem(it) => fld.fold_item(it).move_iter().map(|i| P(Spanned {
+        DeclItem(it) => fld.fold_item(it).into_iter().map(|i| P(Spanned {
             node: DeclItem(i),
             span: fld.new_span(span)
         })).collect()
@@ -819,7 +819,7 @@ pub fn noop_fold_block<T: Folder>(b: P<Block>, folder: &mut T) -> P<Block> {
     b.map(|Block {id, view_items, stmts, expr, rules, span}| Block {
         id: folder.new_id(id),
         view_items: view_items.move_map(|x| folder.fold_view_item(x)),
-        stmts: stmts.move_iter().flat_map(|s| folder.fold_stmt(s).move_iter()).collect(),
+        stmts: stmts.into_iter().flat_map(|s| folder.fold_stmt(s).into_iter()).collect(),
         expr: expr.map(|x| folder.fold_expr(x)),
         rules: rules,
         span: folder.new_span(span),
@@ -860,17 +860,17 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
             ItemImpl(folder.fold_generics(generics),
                      ifce.map(|p| folder.fold_trait_ref(p)),
                      folder.fold_ty(ty),
-                     impl_items.move_iter().flat_map(|impl_item| match impl_item {
+                     impl_items.into_iter().flat_map(|impl_item| match impl_item {
                         MethodImplItem(x) => {
-                            folder.fold_method(x).move_iter().map(|x| MethodImplItem(x))
+                            folder.fold_method(x).into_iter().map(|x| MethodImplItem(x))
                         }
                      }).collect())
         }
         ItemTrait(generics, unbound, bounds, methods) => {
             let bounds = folder.fold_bounds(bounds);
-            let methods = methods.move_iter().flat_map(|method| match method {
+            let methods = methods.into_iter().flat_map(|method| match method {
                 RequiredMethod(m) => {
-                    SmallVector::one(RequiredMethod(folder.fold_type_method(m))).move_iter()
+                    SmallVector::one(RequiredMethod(folder.fold_type_method(m))).into_iter()
                 }
                 ProvidedMethod(method) => {
                     // the awkward collect/iter idiom here is because
@@ -878,9 +878,9 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
                     // they're not actually the same type, so the method arms
                     // don't unify.
                     let methods: SmallVector<ast::TraitItem> =
-                        folder.fold_method(method).move_iter()
+                        folder.fold_method(method).into_iter()
                         .map(|m| ProvidedMethod(m)).collect();
-                    methods.move_iter()
+                    methods.into_iter()
                 }
             }).collect();
             ItemTrait(folder.fold_generics(generics),
@@ -912,7 +912,7 @@ pub fn noop_fold_mod<T: Folder>(Mod {inner, view_items, items}: Mod, folder: &mu
     Mod {
         inner: folder.new_span(inner),
         view_items: view_items.move_map(|x| folder.fold_view_item(x)),
-        items: items.move_iter().flat_map(|x| folder.fold_item(x).move_iter()).collect(),
+        items: items.into_iter().flat_map(|x| folder.fold_item(x).into_iter()).collect(),
     }
 }
 
@@ -1194,7 +1194,7 @@ pub fn noop_fold_stmt<T: Folder>(Spanned {node, span}: Stmt, folder: &mut T)
     match node {
         StmtDecl(d, id) => {
             let id = folder.new_id(id);
-            folder.fold_decl(d).move_iter().map(|d| P(Spanned {
+            folder.fold_decl(d).into_iter().map(|d| P(Spanned {
                 node: StmtDecl(d, id),
                 span: span
             })).collect()
diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
index 33482ec0eb3..798a54c1062 100644
--- a/src/libsyntax/owned_slice.rs
+++ b/src/libsyntax/owned_slice.rs
@@ -49,7 +49,7 @@ impl<T> Drop for OwnedSlice<T> {
 
 impl<T> OwnedSlice<T> {
     pub fn empty() -> OwnedSlice<T> {
-        OwnedSlice  { data: ptr::mut_null(), len: 0 }
+        OwnedSlice  { data: ptr::null_mut(), len: 0 }
     }
 
     #[inline(never)]
@@ -106,7 +106,7 @@ impl<T> OwnedSlice<T> {
     }
 
     pub fn move_iter(self) -> vec::MoveItems<T> {
-        self.into_vec().move_iter()
+        self.into_vec().into_iter()
     }
 
     pub fn map<U>(&self, f: |&T| -> U) -> OwnedSlice<U> {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 84484841613..a6a2ecb199a 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1295,7 +1295,7 @@ impl<'a> Parser<'a> {
                 let (inner_attrs, body) =
                     p.parse_inner_attrs_and_block();
                 let mut attrs = attrs;
-                attrs.extend(inner_attrs.move_iter());
+                attrs.extend(inner_attrs.into_iter());
                 ProvidedMethod(P(ast::Method {
                     attrs: attrs,
                     id: ast::DUMMY_NODE_ID,
@@ -1404,7 +1404,7 @@ impl<'a> Parser<'a> {
 
                 if ts.len() == 1 && !one_tuple {
                     self.expect(&token::RPAREN);
-                    TyParen(ts.move_iter().nth(0).unwrap())
+                    TyParen(ts.into_iter().nth(0).unwrap())
                 } else {
                     let t = TyTup(ts);
                     self.expect(&token::RPAREN);
@@ -2011,7 +2011,7 @@ impl<'a> Parser<'a> {
                 self.commit_expr_expecting(&**es.last().unwrap(), token::RPAREN);
 
                 return if es.len() == 1 && !trailing_comma {
-                   self.mk_expr(lo, hi, ExprParen(es.move_iter().nth(0).unwrap()))
+                   self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()))
                 } else {
                     self.mk_expr(lo, hi, ExprTup(es))
                 }
@@ -3500,7 +3500,7 @@ impl<'a> Parser<'a> {
         } = self.parse_items_and_view_items(first_item_attrs,
                                             false, false);
 
-        for item in items.move_iter() {
+        for item in items.into_iter() {
             let span = item.span;
             let decl = P(spanned(span.lo, span.hi, DeclItem(item)));
             stmts.push(P(spanned(span.lo, span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))));
@@ -3898,7 +3898,7 @@ impl<'a> Parser<'a> {
                           "variadic function must be declared with at least one named argument");
         }
 
-        let args = args.move_iter().map(|x| x.unwrap()).collect();
+        let args = args.into_iter().map(|x| x.unwrap()).collect();
 
         (args, variadic)
     }
@@ -4958,7 +4958,7 @@ impl<'a> Parser<'a> {
                     seq_sep_trailing_allowed(token::COMMA),
                     |p| p.parse_ty(true)
                 );
-                for ty in arg_tys.move_iter() {
+                for ty in arg_tys.into_iter() {
                     args.push(ast::VariantArg {
                         ty: ty,
                         id: ast::DUMMY_NODE_ID,
@@ -5057,7 +5057,7 @@ impl<'a> Parser<'a> {
                 self.bump();
                 let mut attrs = attrs;
                 mem::swap(&mut item.attrs, &mut attrs);
-                item.attrs.extend(attrs.move_iter());
+                item.attrs.extend(attrs.into_iter());
                 return IoviItem(P(item));
             }
             None => {}
@@ -5408,7 +5408,7 @@ impl<'a> Parser<'a> {
             let path = ast::Path {
                 span: span,
                 global: false,
-                segments: path.move_iter().map(|identifier| {
+                segments: path.into_iter().map(|identifier| {
                     ast::PathSegment {
                         identifier: identifier,
                         lifetimes: Vec::new(),
@@ -5443,7 +5443,7 @@ impl<'a> Parser<'a> {
                     let path = ast::Path {
                         span: mk_sp(lo, self.span.hi),
                         global: false,
-                        segments: path.move_iter().map(|identifier| {
+                        segments: path.into_iter().map(|identifier| {
                             ast::PathSegment {
                                 identifier: identifier,
                                 lifetimes: Vec::new(),
@@ -5461,7 +5461,7 @@ impl<'a> Parser<'a> {
                     let path = ast::Path {
                         span: mk_sp(lo, self.span.hi),
                         global: false,
-                        segments: path.move_iter().map(|identifier| {
+                        segments: path.into_iter().map(|identifier| {
                             ast::PathSegment {
                                 identifier: identifier,
                                 lifetimes: Vec::new(),
@@ -5483,7 +5483,7 @@ impl<'a> Parser<'a> {
         let path = ast::Path {
             span: mk_sp(lo, self.span.hi),
             global: false,
-            segments: path.move_iter().map(|identifier| {
+            segments: path.into_iter().map(|identifier| {
                 ast::PathSegment {
                     identifier: identifier,
                     lifetimes: Vec::new(),
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 47aef987a63..a3f081e7be4 100644
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -90,7 +90,7 @@ impl<T> SmallVector<T> {
     }
 
     pub fn push_all(&mut self, other: SmallVector<T>) {
-        for v in other.move_iter() {
+        for v in other.into_iter() {
             self.push(v);
         }
     }
@@ -108,7 +108,7 @@ impl<T> SmallVector<T> {
             One(v) => v,
             Many(v) => {
                 if v.len() == 1 {
-                    v.move_iter().next().unwrap()
+                    v.into_iter().next().unwrap()
                 } else {
                     fail!(err)
                 }
@@ -117,11 +117,17 @@ impl<T> SmallVector<T> {
         }
     }
 
+    /// Deprecated: use `into_iter`.
+    #[deprecated = "use into_iter"]
     pub fn move_iter(self) -> MoveItems<T> {
+        self.into_iter()
+    }
+
+    pub fn into_iter(self) -> MoveItems<T> {
         let repr = match self.repr {
             Zero => ZeroIterator,
             One(v) => OneIterator(v),
-            Many(vs) => ManyIterator(vs.move_iter())
+            Many(vs) => ManyIterator(vs.into_iter())
         };
         MoveItems { repr: repr }
     }
@@ -202,7 +208,7 @@ mod test {
 
     #[test]
     fn test_from_iter() {
-        let v: SmallVector<int> = (vec!(1i, 2, 3)).move_iter().collect();
+        let v: SmallVector<int> = (vec!(1i, 2, 3)).into_iter().collect();
         assert_eq!(3, v.len());
         assert_eq!(&1, v.get(0));
         assert_eq!(&2, v.get(1));
@@ -212,14 +218,14 @@ mod test {
     #[test]
     fn test_move_iter() {
         let v = SmallVector::zero();
-        let v: Vec<int> = v.move_iter().collect();
+        let v: Vec<int> = v.into_iter().collect();
         assert_eq!(Vec::new(), v);
 
         let v = SmallVector::one(1i);
-        assert_eq!(vec!(1i), v.move_iter().collect());
+        assert_eq!(vec!(1i), v.into_iter().collect());
 
         let v = SmallVector::many(vec!(1i, 2i, 3i));
-        assert_eq!(vec!(1i, 2i, 3i), v.move_iter().collect());
+        assert_eq!(vec!(1i, 2i, 3i), v.into_iter().collect());
     }
 
     #[test]