From fc525eeb4ec3443d29bce677f589b19f31c189bb Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Sun, 14 Sep 2014 20:27:36 -0700 Subject: Fallout from renaming --- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/build.rs | 4 ++-- src/libsyntax/ext/concat.rs | 2 +- src/libsyntax/ext/deriving/cmp/totaleq.rs | 2 +- src/libsyntax/ext/deriving/generic/mod.rs | 18 +++++++++--------- src/libsyntax/ext/env.rs | 2 +- src/libsyntax/ext/expand.rs | 26 +++++++++++++------------- src/libsyntax/ext/format.rs | 8 ++++---- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 2 +- src/libsyntax/ext/tt/transcribe.rs | 12 ++++++------ 11 files changed, 40 insertions(+), 40 deletions(-) (limited to 'src/libsyntax/ext') 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> ) -> ast::Path { let last_identifier = idents.pop().unwrap(); - let mut segments: Vec = idents.move_iter() + let mut segments: Vec = 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> ) -> 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.(); b.(); c.(); ...` // (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, P)>> = 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, fld: &mut MacroExpander) let mut items: SmallVector> = 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, 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> { 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, fld: &mut MacroExpander) -> P { // expand the elements of a block. pub fn expand_block_elts(b: P, fld: &mut MacroExpander) -> P { 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, fld: &mut MacroExpander) -> P { 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, fld: &mut MacroExpander) -> SmallVector", 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 ToTokens for Vec { fn to_tokens(&self, cx: &ExtCtxt) -> Vec { - 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 -- cgit 1.4.1-3-g733a5