about summary refs log tree commit diff
path: root/src/libsyntax/ext
diff options
context:
space:
mode:
Diffstat (limited to 'src/libsyntax/ext')
-rw-r--r--src/libsyntax/ext/base.rs2
-rw-r--r--src/libsyntax/ext/build.rs4
-rw-r--r--src/libsyntax/ext/concat.rs2
-rw-r--r--src/libsyntax/ext/deriving/cmp/totaleq.rs2
-rw-r--r--src/libsyntax/ext/deriving/generic/mod.rs18
-rw-r--r--src/libsyntax/ext/env.rs2
-rw-r--r--src/libsyntax/ext/expand.rs26
-rw-r--r--src/libsyntax/ext/format.rs8
-rw-r--r--src/libsyntax/ext/quote.rs2
-rw-r--r--src/libsyntax/ext/tt/macro_parser.rs2
-rw-r--r--src/libsyntax/ext/tt/transcribe.rs12
11 files changed, 40 insertions, 40 deletions
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
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-03-12 19:03:24 +0000