OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #7055 : thestinger/rust/iterator, r=catamorphism 

This was a lot more painful than just changing `x.each` to `x.iter().advance` . I ran into my old friend #5898 and had to add underscores to some method names as a temporary workaround.

The borrow checker also had other ideas because rvalues aren't handled very well yet so temporary variables had to be added. However, storing the temporary in a variable led to dynamic `@mut` failures, so those had to be wrapped in blocks except where the scope ends immediately.

Anyway, the ugliness will be fixed as the compiler issues are fixed and this change will amount to `for x.each |x|` becoming `for x.iter |x|` and making all the iterator adaptors available.

I dropped the run-pass tests for `old_iter` because there's not much point in fixing a module that's on the way out in the next week or so.
This commit is contained in:
bors 2013-06-11 16:19:42 -07:00
parent 1175e94de3 bbe3d4a9dc
commit 3f900dc7d1
70 changed files with 486 additions and 638 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/compiletest/procsrv.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use core::prelude::*;
use core::iterator::IteratorUtil;
use core::os;
use core::run;
@ -58,7 +59,7 @@ pub fn run(lib_path: &str,
err_fd: None
});
for input.each |input| {
for input.iter().advance |input| {
proc.input().write_str(*input);
}
let output = proc.finish_with_output();

4
src/libextra/par.rs
View File

@ -139,8 +139,8 @@ pub fn any<A:Copy + Owned>(
fn_factory: &fn() -> ~fn(&A) -> bool) -> bool {
let mapped = map_slices(xs, || {
let f = fn_factory();
let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any(f);
let result: ~fn(uint, &[A]) -> bool = |_, slice| slice.iter().any_(f);
result
});
mapped.iter().any(|&x| x)
mapped.iter().any_(|&x| x)
}

23
src/libextra/treemap.rs
View File

@ -427,7 +427,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
b = y.next();
}
}
return b.each(|&x| f(x)) && y.advance(f);
b.iter().advance(|&x| f(x)) && y.advance(f)
}
/// Visit the values (in-order) representing the intersection
@ -485,7 +485,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
a = x.next();
}
}
return b.each(|&x| f(x)) && y.advance(f);
b.iter().advance(|&x| f(x)) && y.advance(f)
}
}
@ -527,14 +527,14 @@ impl<K: TotalOrd, V> TreeNode<K, V> {
fn each<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
f: &fn(&'r K, &'r V) -> bool) -> bool {
node.each(|x| each(&x.left, f) && f(&x.key, &x.value) &&
each(&x.right, f))
node.iter().advance(|x| each(&x.left, f) && f(&x.key, &x.value) &&
each(&x.right, f))
}
fn each_reverse<'r, K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
f: &fn(&'r K, &'r V) -> bool) -> bool {
node.each(|x| each_reverse(&x.right, f) && f(&x.key, &x.value) &&
each_reverse(&x.left, f))
node.iter().advance(|x| each_reverse(&x.right, f) && f(&x.key, &x.value) &&
each_reverse(&x.left, f))
}
fn mutate_values<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
@ -625,7 +625,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
fn heir_swap<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>,
child: &mut Option<~TreeNode<K, V>>) {
// *could* be done without recursion, but it won't borrow check
for child.each_mut |x| {
for child.mut_iter().advance |x| {
if x.right.is_some() {
heir_swap(node, &mut x.right);
} else {
@ -680,18 +680,18 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
save.level -= 1;
if right_level > save.level {
for save.right.each_mut |x| { x.level = save.level }
for save.right.mut_iter().advance |x| { x.level = save.level }
}
skew(save);
for save.right.each_mut |right| {
for save.right.mut_iter().advance |right| {
skew(right);
for right.right.each_mut |x| { skew(x) }
for right.right.mut_iter().advance |x| { skew(x) }
}
split(save);
for save.right.each_mut |x| { split(x) }
for save.right.mut_iter().advance |x| { split(x) }
}
return ret;
@ -1111,6 +1111,7 @@ mod test_set {
let mut n = 0;
for m.each |x| {
println(fmt!("%?", x));
assert_eq!(*x, n);
n += 1
}

4
src/librust/rust.rc
View File

@ -30,6 +30,7 @@ extern mod rusti;
extern mod rustc;
use core::prelude::*;
use core::iterator::IteratorUtil;
use core::io;
use core::os;
@ -242,7 +243,8 @@ pub fn main() {
let args = os_args.tail();
if !args.is_empty() {
for find_cmd(*args.head()).each |command| {
let r = find_cmd(*args.head());
for r.iter().advance |command| {
let result = do_command(command, args.tail());
match result {
Valid(exit_code) => unsafe { exit(exit_code.to_i32()) },

7
src/librustc/metadata/encoder.rs
View File

@ -22,6 +22,7 @@ use middle::ty;
use middle;
use util::ppaux::ty_to_str;
use core::iterator::IteratorUtil;
use core::hash::HashUtil;
use core::hashmap::HashMap;
use core::int;
@ -120,7 +121,7 @@ fn encode_region_param(ecx: @EncodeContext,
ebml_w: &mut writer::Encoder,
it: @ast::item) {
let opt_rp = ecx.tcx.region_paramd_items.find(&it.id);
for opt_rp.each |rp| {
for opt_rp.iter().advance |rp| {
ebml_w.start_tag(tag_region_param);
rp.encode(ebml_w);
ebml_w.end_tag();
@ -240,7 +241,7 @@ fn encode_type(ecx: @EncodeContext,
fn encode_transformed_self_ty(ecx: @EncodeContext,
ebml_w: &mut writer::Encoder,
opt_typ: Option<ty::t>) {
for opt_typ.each |&typ| {
for opt_typ.iter().advance |&typ| {
ebml_w.start_tag(tag_item_method_transformed_self_ty);
write_type(ecx, ebml_w, typ);
ebml_w.end_tag();
@ -956,7 +957,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
ebml_w.writer.write(str::to_bytes(def_to_str(method_def_id)));
ebml_w.end_tag();
}
for opt_trait.each |ast_trait_ref| {
for opt_trait.iter().advance |ast_trait_ref| {
let trait_ref = ty::node_id_to_trait_ref(ecx.tcx, ast_trait_ref.ref_id);
encode_trait_ref(ebml_w, ecx, trait_ref, tag_item_trait_ref);
}

135
src/librustc/middle/astencode.rs
View File

@ -25,6 +25,7 @@ use middle::{ty, typeck, moves};
use middle;
use util::ppaux::ty_to_str;
use core::iterator::IteratorUtil;
use core::at_vec;
use core::uint;
use extra::ebml::reader;
@ -826,86 +827,113 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
debug!("Encoding side tables for id %d", id);
for tcx.def_map.find(&id).each |def| {
do ebml_w.tag(c::tag_table_def) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
(*def).encode(ebml_w)
{
let r = tcx.def_map.find(&id);
for r.iter().advance |def| {
do ebml_w.tag(c::tag_table_def) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
(*def).encode(ebml_w)
}
}
}
}
for tcx.node_types.find(&(id as uint)).each |&ty| {
do ebml_w.tag(c::tag_table_node_type) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_ty(ecx, *ty);
{
let r = tcx.node_types.find(&(id as uint));
for r.iter().advance |&ty| {
do ebml_w.tag(c::tag_table_node_type) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_ty(ecx, *ty);
}
}
}
}
for tcx.node_type_substs.find(&id).each |tys| {
do ebml_w.tag(c::tag_table_node_type_subst) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_tys(ecx, **tys)
{
let r = tcx.node_type_substs.find(&id);
for r.iter().advance |tys| {
do ebml_w.tag(c::tag_table_node_type_subst) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_tys(ecx, **tys)
}
}
}
}
for tcx.freevars.find(&id).each |&fv| {
do ebml_w.tag(c::tag_table_freevars) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
do ebml_w.emit_from_vec(**fv) |ebml_w, fv_entry| {
encode_freevar_entry(ebml_w, *fv_entry)
{
let r = tcx.freevars.find(&id);
for r.iter().advance |&fv| {
do ebml_w.tag(c::tag_table_freevars) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
do ebml_w.emit_from_vec(**fv) |ebml_w, fv_entry| {
encode_freevar_entry(ebml_w, *fv_entry)
}
}
}
}
}
let lid = ast::def_id { crate: ast::local_crate, node: id };
for tcx.tcache.find(&lid).each |&tpbt| {
do ebml_w.tag(c::tag_table_tcache) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_tpbt(ecx, *tpbt);
{
let r = tcx.tcache.find(&lid);
for r.iter().advance |&tpbt| {
do ebml_w.tag(c::tag_table_tcache) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_tpbt(ecx, *tpbt);
}
}
}
}
for tcx.ty_param_defs.find(&id).each |&type_param_def| {
do ebml_w.tag(c::tag_table_param_defs) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_type_param_def(ecx, type_param_def)
{
let r = tcx.ty_param_defs.find(&id);
for r.iter().advance |&type_param_def| {
do ebml_w.tag(c::tag_table_param_defs) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
ebml_w.emit_type_param_def(ecx, type_param_def)
}
}
}
}
for maps.method_map.find(&id).each |&mme| {
do ebml_w.tag(c::tag_table_method_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
encode_method_map_entry(ecx, ebml_w, *mme)
{
let r = maps.method_map.find(&id);
for r.iter().advance |&mme| {
do ebml_w.tag(c::tag_table_method_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
encode_method_map_entry(ecx, ebml_w, *mme)
}
}
}
}
for maps.vtable_map.find(&id).each |&dr| {
do ebml_w.tag(c::tag_table_vtable_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
encode_vtable_res(ecx, ebml_w, *dr);
{
let r = maps.vtable_map.find(&id);
for r.iter().advance |&dr| {
do ebml_w.tag(c::tag_table_vtable_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
encode_vtable_res(ecx, ebml_w, *dr);
}
}
}
}
for tcx.adjustments.find(&id).each |adj| {
do ebml_w.tag(c::tag_table_adjustments) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
(**adj).encode(ebml_w)
{
let r = tcx.adjustments.find(&id);
for r.iter().advance |adj| {
do ebml_w.tag(c::tag_table_adjustments) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
(**adj).encode(ebml_w)
}
}
}
}
@ -916,12 +944,15 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
}
}
for maps.capture_map.find(&id).each |&cap_vars| {
do ebml_w.tag(c::tag_table_capture_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
do ebml_w.emit_from_vec(*cap_vars) |ebml_w, cap_var| {
cap_var.encode(ebml_w);
{
let r = maps.capture_map.find(&id);
for r.iter().advance |&cap_vars| {
do ebml_w.tag(c::tag_table_capture_map) |ebml_w| {
ebml_w.id(id);
do ebml_w.tag(c::tag_table_val) |ebml_w| {
do ebml_w.emit_from_vec(*cap_vars) |ebml_w, cap_var| {
cap_var.encode(ebml_w);
}
}
}
}

12
src/librustc/middle/borrowck/check_loans.rs
View File

@ -18,6 +18,7 @@
// 4. moves do not affect things loaned out in any way
use core::prelude::*;
use core::iterator::IteratorUtil;
use core::hashmap::HashSet;
use core::uint;
@ -581,14 +582,15 @@ impl<'self> CheckLoanCtxt<'self> {
// FIXME(#4384) inadequare if/when we permit `move a.b`
// check for a conflicting loan:
for opt_loan_path(cmt).each |&lp| {
let r = opt_loan_path(cmt);
for r.iter().advance |&lp| {
for self.each_in_scope_restriction(cmt.id, lp) |loan, _| {
// Any restriction prevents moves.
return MoveWhileBorrowed(lp, loan.loan_path, loan.span);
}
}
return MoveOk;
MoveOk
}
pub fn check_call(&mut self,
@ -700,9 +702,9 @@ fn check_loans_in_expr<'a>(expr: @ast::expr,
if !this.move_data.is_assignee(expr.id) {
let cmt = this.bccx.cat_expr_unadjusted(expr);
debug!("path cmt=%s", cmt.repr(this.tcx()));
for opt_loan_path(cmt).each |&lp| {
this.check_if_path_is_moved(expr.id, expr.span,
MovedInUse, lp);
let r = opt_loan_path(cmt);
for r.iter().advance |&lp| {
this.check_if_path_is_moved(expr.id, expr.span, MovedInUse, lp);
}
}
}

15
src/librustc/middle/borrowck/gather_loans/mod.rs
View File

@ -17,6 +17,7 @@
// sure that all of these loans are honored.
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::borrowck::*;
use middle::borrowck::move_data::MoveData;
@ -176,13 +177,19 @@ fn gather_loans_in_expr(ex: @ast::expr,
this.id_range.add(ex.id);
for ex.get_callee_id().each |callee_id| {
this.id_range.add(*callee_id);
{
let r = ex.get_callee_id();
for r.iter().advance |callee_id| {
this.id_range.add(*callee_id);
}
}
// If this expression is borrowed, have to ensure it remains valid:
for tcx.adjustments.find(&ex.id).each |&adjustments| {
this.guarantee_adjustments(ex, *adjustments);
{
let r = tcx.adjustments.find(&ex.id);
for r.iter().advance |&adjustments| {
this.guarantee_adjustments(ex, *adjustments);
}
}
// If this expression is a move, gather it:

3
src/librustc/middle/borrowck/move_data.rs
View File

@ -16,6 +16,7 @@ comments in the section "Moves and initialization" and in `doc.rs`.
*/
use core::prelude::*;
use core::iterator::IteratorUtil;
use core::hashmap::{HashMap, HashSet};
use core::uint;
@ -516,7 +517,7 @@ impl FlowedMoveData {
loop;
}
for opt_loan_path_index.each |&loan_path_index| {
for opt_loan_path_index.iter().advance |&loan_path_index| {
for self.move_data.each_base_path(moved_path) |p| {
if p == loan_path_index {
// Scenario 3: some extension of `loan_path`

3
src/librustc/middle/check_const.rs
View File

@ -8,6 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use core::iterator::IteratorUtil;
use core::prelude::*;
use driver::session::Session;
@ -49,7 +50,7 @@ pub fn check_item(sess: Session,
}
item_enum(ref enum_definition, _) => {
for (*enum_definition).variants.each |var| {
for var.node.disr_expr.each |ex| {
for var.node.disr_expr.iter().advance |ex| {
(v.visit_expr)(*ex, true, v);
}
}

3
src/librustc/middle/check_match.rs
View File

@ -363,7 +363,8 @@ pub fn missing_ctor(cx: @MatchCheckCtxt,
ty::ty_enum(eid, _) => {
let mut found = ~[];
for m.each |r| {
for pat_ctor_id(cx, r[0]).each |id| {
let r = pat_ctor_id(cx, r[0]);
for r.iter().advance |id| {
if !vec::contains(found, id) {
found.push(/*bad*/copy *id);
}

2
src/librustc/middle/dataflow.rs
View File

@ -794,7 +794,7 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
opt_expr: Option<@ast::expr>,
in_out: &mut [uint],
loop_scopes: &mut ~[LoopScope]) {
for opt_expr.each |&expr| {
for opt_expr.iter().advance |&expr| {
self.walk_expr(expr, in_out, loop_scopes);
}
}

70
src/librustc/middle/kind.rs
View File

@ -245,32 +245,35 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
Some(callee_id) => callee_id,
None => e.id,
};
for cx.tcx.node_type_substs.find(&type_parameter_id).each |ts| {
let type_param_defs = match e.node {
expr_path(_) => {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&e.id));
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs
}
_ => {
// Type substitutions should only occur on paths and
// method calls, so this needs to be a method call.
{
let r = cx.tcx.node_type_substs.find(&type_parameter_id);
for r.iter().advance |ts| {
let type_param_defs = match e.node {
expr_path(_) => {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&e.id));
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs
}
_ => {
// Type substitutions should only occur on paths and
// method calls, so this needs to be a method call.
// Even though the callee_id may have been the id with
// node_type_substs, e.id is correct here.
ty::method_call_type_param_defs(cx.tcx, cx.method_map, e.id).expect(
"non path/method call expr has type substs??")
}
};
if ts.len() != type_param_defs.len() {
// Fail earlier to make debugging easier
fail!("internal error: in kind::check_expr, length \
mismatch between actual and declared bounds: actual = \
%s, declared = %s",
ts.repr(cx.tcx),
type_param_defs.repr(cx.tcx));
}
for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
check_bounds(cx, type_parameter_id, e.span, ty, type_param_def)
// Even though the callee_id may have been the id with
// node_type_substs, e.id is correct here.
ty::method_call_type_param_defs(cx.tcx, cx.method_map, e.id).expect(
"non path/method call expr has type substs??")
}
};
if ts.len() != type_param_defs.len() {
// Fail earlier to make debugging easier
fail!("internal error: in kind::check_expr, length \
mismatch between actual and declared bounds: actual = \
%s, declared = %s",
ts.repr(cx.tcx),
type_param_defs.repr(cx.tcx));
}
for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
check_bounds(cx, type_parameter_id, e.span, ty, type_param_def)
}
}
}
@ -306,14 +309,15 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
fn check_ty(aty: @Ty, cx: Context, v: visit::vt<Context>) {
match aty.node {
ty_path(_, id) => {
for cx.tcx.node_type_substs.find(&id).each |ts| {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&id));
let type_param_defs =
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
check_bounds(cx, aty.id, aty.span, ty, type_param_def)
}
}
let r = cx.tcx.node_type_substs.find(&id);
for r.iter().advance |ts| {
let did = ast_util::def_id_of_def(cx.tcx.def_map.get_copy(&id));
let type_param_defs =
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
for ts.iter().zip(type_param_defs.iter()).advance |(&ty, type_param_def)| {
check_bounds(cx, aty.id, aty.span, ty, type_param_def)
}
}
}
_ => {}
}

3
src/librustc/middle/lint.rs
View File

@ -15,6 +15,7 @@ use middle::ty;
use middle::pat_util;
use util::ppaux::{ty_to_str};
use core::iterator::IteratorUtil;
use core::char;
use core::cmp;
use core::hashmap::HashMap;
@ -388,7 +389,7 @@ impl Context {
allow => fail!(),
}
for note.each |&span| {
for note.iter().advance |&span| {
self.tcx.sess.span_note(span, "lint level defined here");
}
}

16
src/librustc/middle/liveness.rs
View File

@ -114,7 +114,6 @@ use core::iterator::IteratorUtil;
use core::cast::transmute;
use core::hashmap::HashMap;
use core::io;
use core::old_iter;
use core::to_str;
use core::uint;
use core::vec;
@ -987,8 +986,8 @@ impl Liveness {
opt_expr: Option<@expr>,
succ: LiveNode)
-> LiveNode {
do old_iter::foldl(&opt_expr, succ) |succ, expr| {
self.propagate_through_expr(*expr, *succ)
do opt_expr.iter().fold(succ) |succ, expr| {
self.propagate_through_expr(*expr, succ)
}
}
@ -1624,7 +1623,8 @@ impl Liveness {
var: Variable)
-> bool {
if !self.used_on_entry(ln, var) {
for self.should_warn(var).each |name| {
let r = self.should_warn(var);
for r.iter().advance |name| {
// annoying: for parameters in funcs like `fn(x: int)
// {ret}`, there is only one node, so asking about
@ -1644,9 +1644,10 @@ impl Liveness {
fmt!("unused variable: `%s`", **name));
}
}
return true;
true
} else {
false
}
return false;
}
pub fn warn_about_dead_assign(&self,
@ -1655,7 +1656,8 @@ impl Liveness {
ln: LiveNode,
var: Variable) {
if self.live_on_exit(ln, var).is_none() {
for self.should_warn(var).each |name| {
let r = self.should_warn(var);
for r.iter().advance |name| {
self.tcx.sess.add_lint(dead_assignment, id, sp,
fmt!("value assigned to `%s` is never read", **name));
}

3
src/librustc/middle/mem_categorization.rs
View File

@ -47,6 +47,7 @@
*/
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::ty;
use middle::typeck;
@ -948,7 +949,7 @@ impl mem_categorization_ctxt {
for before.each |&before_pat| {
self.cat_pattern(elt_cmt, before_pat, op);
}
for slice.each |&slice_pat| {
for slice.iter().advance |&slice_pat| {
let slice_ty = self.pat_ty(slice_pat);
let slice_cmt = self.cat_rvalue(pat, slice_ty);
self.cat_pattern(slice_cmt, slice_pat, op);

16
src/librustc/middle/moves.rs
View File

@ -127,6 +127,7 @@ and so on.
*/
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::pat_util::{pat_bindings};
use middle::freevars;
@ -267,7 +268,7 @@ impl VisitContext {
(visitor.visit_stmt)(*stmt, *self, visitor);
}
for blk.node.expr.each |tail_expr| {
for blk.node.expr.iter().advance |tail_expr| {
self.consume_expr(*tail_expr, visitor);
}
}
@ -302,7 +303,8 @@ impl VisitContext {
match comp_mode {
Move => {
let def = self.tcx.def_map.get_copy(&expr.id);
for moved_variable_node_id_from_def(def).each |&id| {
let r = moved_variable_node_id_from_def(def);
for r.iter().advance |&id| {
self.move_maps.moved_variables_set.insert(id);
}
}
@ -350,7 +352,7 @@ impl VisitContext {
self.consume_expr(field.node.expr, visitor);
}
for opt_with.each |with_expr| {
for opt_with.iter().advance |with_expr| {
// If there are any fields whose type is move-by-default,
// then `with` is consumed, otherwise it is only read
let with_ty = ty::expr_ty(self.tcx, *with_expr);
@ -389,7 +391,7 @@ impl VisitContext {
expr_if(cond_expr, ref then_blk, opt_else_expr) => {
self.consume_expr(cond_expr, visitor);
self.consume_block(then_blk, visitor);
for opt_else_expr.each |else_expr| {
for opt_else_expr.iter().advance |else_expr| {
self.consume_expr(*else_expr, visitor);
}
}
@ -466,7 +468,7 @@ impl VisitContext {
}
expr_ret(ref opt_expr) => {
for opt_expr.each |expr| {
for opt_expr.iter().advance |expr| {
self.consume_expr(*expr, visitor);
}
}
@ -541,11 +543,11 @@ impl VisitContext {
}
pub fn consume_arm(&self, arm: &arm, visitor: vt<VisitContext>) {
for arm.pats.each |pat| {
for arm.pats.iter().advance |pat| {
self.use_pat(*pat);
}
for arm.guard.each |guard| {
for arm.guard.iter().advance |guard| {
self.consume_expr(*guard, visitor);
}

3
src/librustc/middle/region.rs
View File

@ -26,6 +26,7 @@ use middle::ty::{region_variance, rv_covariant, rv_invariant};
use middle::ty::{rv_contravariant, FreeRegion};
use middle::ty;
use core::iterator::IteratorUtil;
use core::hashmap::{HashMap, HashSet};
use syntax::ast_map;
use syntax::codemap::span;
@ -329,7 +330,7 @@ pub fn parent_id(cx: Context, span: span) -> ast::node_id {
pub fn parent_to_expr(cx: Context, child_id: ast::node_id, sp: span) {
debug!("region::parent_to_expr(span=%?)",
cx.sess.codemap.span_to_str(sp));
for cx.parent.each |parent_id| {
for cx.parent.iter().advance |parent_id| {
cx.region_maps.record_parent(child_id, *parent_id);
}
}

22
src/librustc/middle/resolve.rs
View File

@ -1036,11 +1036,14 @@ impl Resolver {
fmt!("duplicate definition of %s `%s`",
namespace_to_str(ns),
*self.session.str_of(name)));
for child.span_for_namespace(ns).each |sp| {
self.session.span_note(*sp,
fmt!("first definition of %s %s here:",
namespace_to_str(ns),
*self.session.str_of(name)));
{
let r = child.span_for_namespace(ns);
for r.iter().advance |sp| {
self.session.span_note(*sp,
fmt!("first definition of %s %s here:",
namespace_to_str(ns),
*self.session.str_of(name)));
}
}
}
return (child, new_parent);
@ -3490,7 +3493,7 @@ impl Resolver {
// then resolve the ty params
item_enum(ref enum_def, ref generics) => {
for (*enum_def).variants.each() |variant| {
for variant.node.disr_expr.each |dis_expr| {
for variant.node.disr_expr.iter().advance |dis_expr| {
// resolve the discriminator expr
// as a constant
self.with_constant_rib(|| {
@ -3907,8 +3910,11 @@ impl Resolver {
// Record the current set of trait references.
let mut new_trait_refs = ~[];
for self.def_map.find(&trait_reference.ref_id).each |&def| {
new_trait_refs.push(def_id_of_def(*def));
{
let r = self.def_map.find(&trait_reference.ref_id);
for r.iter().advance |&def| {
new_trait_refs.push(def_id_of_def(*def));
}
}
original_trait_refs = Some(util::replace(
&mut self.current_trait_refs,

16
src/librustc/middle/trans/_match.rs
View File

@ -799,7 +799,7 @@ pub fn enter_region<'r>(bcx: block,
pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
let ccx = bcx.ccx();
fn add_to_set(tcx: ty::ctxt, set: &mut ~[Opt], val: Opt) {
if set.iter().any(|l| opt_eq(tcx, l, &val)) {return;}
if set.iter().any_(|l| opt_eq(tcx, l, &val)) {return;}
set.push(val);
}
@ -966,7 +966,7 @@ pub fn collect_record_or_struct_fields(bcx: block,
fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) {
for field_pats.each |field_pat| {
let field_ident = field_pat.ident;
if !idents.iter().any(|x| *x == field_ident) {
if !idents.iter().any_(|x| *x == field_ident) {
idents.push(field_ident);
}
}
@ -977,7 +977,7 @@ pub fn pats_require_rooting(bcx: block,
m: &[@Match],
col: uint)
-> bool {
do m.iter().any |br| {
do m.iter().any_ |br| {
let pat_id = br.pats[col].id;
let key = root_map_key {id: pat_id, derefs: 0u };
bcx.ccx().maps.root_map.contains_key(&key)
@ -1006,7 +1006,7 @@ pub fn root_pats_as_necessary(mut bcx: block,
// matches may be wildcards like _ or identifiers).
macro_rules! any_pat (
($m:expr, $pattern:pat) => (
do ($m).iter().any |br| {
do ($m).iter().any_ |br| {
match br.pats[col].node {
$pattern => true,
_ => false
@ -1032,7 +1032,7 @@ pub fn any_tup_pat(m: &[@Match], col: uint) -> bool {
}
pub fn any_tuple_struct_pat(bcx: block, m: &[@Match], col: uint) -> bool {
do m.iter().any |br| {
do m.iter().any_ |br| {
let pat = br.pats[col];
match pat.node {
ast::pat_enum(_, Some(_)) => {
@ -1427,7 +1427,7 @@ pub fn compile_submatch(bcx: block,
var(_, repr) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val);
kind = the_kind;
for val_opt.each |&tval| { test_val = tval; }
for val_opt.iter().advance |&tval| { test_val = tval; }
}
lit(_) => {
let pty = node_id_type(bcx, pat_id);
@ -1792,7 +1792,7 @@ pub fn bind_irrefutable_pat(bcx: block,
}
}
for inner.each |inner_pat| {
for inner.iter().advance |inner_pat| {
bcx = bind_irrefutable_pat(
bcx, *inner_pat, val, true, binding_mode);
}
@ -1808,7 +1808,7 @@ pub fn bind_irrefutable_pat(bcx: block,
repr,
vinfo.disr_val,
val);
for sub_pats.each |sub_pat| {
for sub_pats.iter().advance |sub_pat| {
for args.vals.eachi |i, argval| {
bcx = bind_irrefutable_pat(bcx,
sub_pat[i],

16
src/librustc/middle/trans/base.rs
View File

@ -1195,7 +1195,7 @@ pub fn new_block(cx: fn_ctxt, parent: Option<block>, kind: block_kind,
is_lpad,
opt_node_info,
cx);
for parent.each |cx| {
for parent.iter().advance |cx| {
if cx.unreachable { Unreachable(bcx); }
};
bcx
@ -1314,10 +1314,12 @@ pub fn cleanup_and_leave(bcx: block,
block_scope(inf) if !inf.empty_cleanups() => {
let (sub_cx, inf_cleanups) = {
let inf = &mut *inf; // FIXME(#5074) workaround stage0
for vec::find((*inf).cleanup_paths,
|cp| cp.target == leave).each |cp| {
Br(bcx, cp.dest);
return;
{
let r = vec::find((*inf).cleanup_paths, |cp| cp.target == leave);
for r.iter().advance |cp| {
Br(bcx, cp.dest);
return;
}
}
let sub_cx = sub_block(bcx, "cleanup");
Br(bcx, sub_cx.llbb);
@ -1423,7 +1425,7 @@ pub fn alloc_local(cx: block, local: @ast::local) -> block {
};
let val = alloc_ty(cx, t);
if cx.sess().opts.debuginfo {
for simple_name.each |name| {
for simple_name.iter().advance |name| {
str::as_c_str(*cx.ccx().sess.str_of(*name), |buf| {
unsafe {
llvm::LLVMSetValueName(val, buf)
@ -1599,7 +1601,7 @@ pub fn new_fn_ctxt_w_id(ccx: @CrateContext,
param_substs: Option<@param_substs>,
sp: Option<span>)
-> fn_ctxt {
for param_substs.each |p| { p.validate(); }
for param_substs.iter().advance |p| { p.validate(); }
debug!("new_fn_ctxt_w_id(path=%s, id=%?, impl_id=%?, \
param_substs=%s)",

10
src/librustc/middle/trans/callee.rs
View File

@ -17,6 +17,7 @@
// closure.
use core::prelude::*;
use core::iterator::IteratorUtil;
use back::abi;
use driver::session;
@ -582,9 +583,12 @@ pub fn trans_call_inner(in_cx: block,
} else if ret_in_loop {
let ret_flag_result = bool_to_i1(bcx, Load(bcx, ret_flag.get()));
bcx = do with_cond(bcx, ret_flag_result) |bcx| {
for (copy bcx.fcx.loop_ret).each |&(flagptr, _)| {
Store(bcx, C_bool(true), flagptr);
Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
{
let r = (copy bcx.fcx.loop_ret);
for r.iter().advance |&(flagptr, _)| {
Store(bcx, C_bool(true), flagptr);
Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
}
}
base::cleanup_and_leave(bcx, None, Some(bcx.fcx.llreturn));
Unreachable(bcx);

3
src/librustc/middle/trans/closure.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use core::prelude::*;
use core::iterator::IteratorUtil;
use back::abi;
use back::link::{mangle_internal_name_by_path_and_seq};
@ -286,7 +287,7 @@ pub fn build_closure(bcx0: block,
// If this is a `for` loop body, add two special environment
// variables:
for include_ret_handle.each |flagptr| {
for include_ret_handle.iter().advance |flagptr| {
// Flag indicating we have returned (a by-ref bool):
let flag_datum = Datum {val: *flagptr, ty: ty::mk_bool(),
mode: ByRef(ZeroMem)};

5
src/librustc/middle/trans/common.rs
View File

@ -11,6 +11,7 @@
//! Code that is useful in various trans modules.
use core::prelude::*;
use core::iterator::IteratorUtil;
use back::{abi, upcall};
use driver::session;
@ -254,7 +255,7 @@ pub struct param_substs {
impl param_substs {
pub fn validate(&self) {
for self.tys.each |t| { assert!(!ty::type_needs_infer(*t)); }
for self.self_ty.each |t| { assert!(!ty::type_needs_infer(*t)); }
for self.self_ty.iter().advance |t| { assert!(!ty::type_needs_infer(*t)); }
}
}
@ -554,7 +555,7 @@ pub fn revoke_clean(cx: block, val: ValueRef) {
clean_temp(v, _, _) if v == val => true,
_ => false
});
for cleanup_pos.each |i| {
for cleanup_pos.iter().advance |i| {
scope_info.cleanups =
vec::append(vec::slice(scope_info.cleanups, 0u, *i).to_vec(),
vec::slice(scope_info.cleanups,

7
src/librustc/middle/trans/expr.rs
View File

@ -152,6 +152,7 @@ use middle::ty;
use util::common::indenter;
use util::ppaux::Repr;
use core::iterator::IteratorUtil;
use core::cast::transmute;
use core::hashmap::HashMap;
use core::vec;
@ -1223,7 +1224,7 @@ fn trans_adt(bcx: block, repr: &adt::Repr, discr: int,
for fields.each |&(_i, e)| {
bcx = trans_into(bcx, e, Ignore);
}
for optbase.each |sbi| {
for optbase.iter().advance |sbi| {
bcx = trans_into(bcx, sbi.expr, Ignore);
}
return bcx;
@ -1239,11 +1240,11 @@ fn trans_adt(bcx: block, repr: &adt::Repr, discr: int,
add_clean_temp_mem(bcx, dest, e_ty);
temp_cleanups.push(dest);
}
for optbase.each |base| {
for optbase.iter().advance |base| {
// FIXME #6573: is it sound to use the destination's repr on the base?
// And, would it ever be reasonable to be here with discr != 0?
let base_datum = unpack_datum!(bcx, trans_to_datum(bcx, base.expr));
for base.fields.each |&(i, t)| {
for base.fields.iter().advance |&(i, t)| {
let datum = do base_datum.get_element(bcx, t, ZeroMem) |srcval| {
adt::trans_field_ptr(bcx, repr, srcval, discr, i)
};

2
src/librustc/middle/trans/monomorphize.rs
View File

@ -76,7 +76,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len());
let hash_id = make_mono_id(ccx, fn_id, substs, vtables, impl_did_opt,
Some(param_uses));
if hash_id.params.iter().any(
if hash_id.params.iter().any_(
|p| match *p { mono_precise(_, _) => false, _ => true }) {
must_cast = true;
}

3
src/librustc/middle/trans/reachable.rs
View File

@ -16,6 +16,7 @@
// reachable as well.
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::resolve;
use middle::ty;
@ -136,7 +137,7 @@ fn traverse_public_item(cx: @mut ctx, item: @item) {
}
}
item_struct(ref struct_def, _) => {
for struct_def.ctor_id.each |&ctor_id| {
for struct_def.ctor_id.iter().advance |&ctor_id| {
let cx = &mut *cx; // FIXME(#6269) reborrow @mut to &mut
cx.rmap.insert(ctor_id);
}

46
src/librustc/middle/trans/type_use.rs
View File

@ -242,19 +242,22 @@ pub fn node_type_needs(cx: Context, use_: uint, id: node_id) {
pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
let mut opt_static_did = None;
for cx.ccx.maps.method_map.find(&e_id).each |mth| {
match mth.origin {
typeck::method_static(did) => {
opt_static_did = Some(did);
}
typeck::method_param(typeck::method_param {
param_num: param,
_
}) => {
cx.uses[param] |= use_tydesc;
}
typeck::method_trait(*) | typeck::method_self(*)
| typeck::method_super(*) => (),
{
let r = cx.ccx.maps.method_map.find(&e_id);
for r.iter().advance |mth| {
match mth.origin {
typeck::method_static(did) => {
opt_static_did = Some(did);
}
typeck::method_param(typeck::method_param {
param_num: param,
_
}) => {
cx.uses[param] |= use_tydesc;
}
typeck::method_trait(*) | typeck::method_self(*)
| typeck::method_super(*) => (),
}
}
}
@ -262,11 +265,14 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
// above because the recursive call to `type_needs` can trigger
// inlining and hence can cause `method_map` and
// `node_type_substs` to be modified.
for opt_static_did.each |&did| {
for cx.ccx.tcx.node_type_substs.find_copy(&callee_id).each |ts| {
let type_uses = type_uses_for(cx.ccx, did, ts.len());
for type_uses.iter().zip(ts.iter()).advance |(uses, subst)| {
type_needs(cx, *uses, *subst)
for opt_static_did.iter().advance |&did| {
{
let r = cx.ccx.tcx.node_type_substs.find_copy(&callee_id);
for r.iter().advance |ts| {
let type_uses = type_uses_for(cx.ccx, did, ts.len());
for type_uses.iter().zip(ts.iter()).advance |(uses, subst)| {
type_needs(cx, *uses, *subst)
}
}
}
}
@ -300,7 +306,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
}
expr_path(_) | expr_self => {
let opt_ts = cx.ccx.tcx.node_type_substs.find_copy(&e.id);
for opt_ts.each |ts| {
for opt_ts.iter().advance |ts| {
let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get_copy(&e.id));
let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
for uses_for_ts.iter().zip(ts.iter()).advance |(uses, subst)| {
@ -390,7 +396,7 @@ pub fn handle_body(cx: Context, body: &blk) {
},
visit_block: |b, cx, v| {
visit::visit_block(b, cx, v);
for b.node.expr.each |e| {
for b.node.expr.iter().advance |e| {
node_type_needs(cx, use_repr, e.id);
}
},

10
src/librustc/middle/ty.rs
View File

@ -1017,7 +1017,7 @@ fn mk_t(cx: ctxt, st: sty) -> t {
fn sflags(substs: &substs) -> uint {
let mut f = 0u;
for substs.tps.each |tt| { f |= get(*tt).flags; }
for substs.self_r.each |r| { f |= rflags(*r) }
for substs.self_r.iter().advance |r| { f |= rflags(*r) }
return f;
}
match &st {
@ -1560,8 +1560,8 @@ pub fn type_needs_subst(ty: t) -> bool {
}
pub fn trait_ref_contains_error(tref: &ty::TraitRef) -> bool {
tref.substs.self_ty.any(|&t| type_is_error(t)) ||
tref.substs.tps.any(|&t| type_is_error(t))
tref.substs.self_ty.iter().any_(|&t| type_is_error(t)) ||
tref.substs.tps.iter().any_(|&t| type_is_error(t))
}
pub fn type_is_ty_var(ty: t) -> bool {
@ -2357,7 +2357,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
ty_struct(did, ref substs) => {
seen.push(did);
let fields = struct_fields(cx, did, substs);
let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty));
let r = fields.iter().any_(|f| type_requires(cx, seen, r_ty, f.mt.ty));
seen.pop();
r
}
@ -2374,7 +2374,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
seen.push(did);
let vs = enum_variants(cx, did);
let r = !vs.is_empty() && do vs.iter().all |variant| {
do variant.args.iter().any |aty| {
do variant.args.iter().any_ |aty| {
let sty = subst(cx, substs, *aty);
type_requires(cx, seen, r_ty, sty)
}

6
src/librustc/middle/typeck/check/_match.rs
View File

@ -231,7 +231,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
}
if !error_happened {
for subpats.each |pats| {
for subpats.iter().advance |pats| {
for pats.iter().zip(arg_types.iter()).advance |(subpat, arg_ty)| {
check_pat(pcx, *subpat, *arg_ty);
}
@ -248,7 +248,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: @ast::Path,
}
if error_happened {
for subpats.each |pats| {
for subpats.iter().advance |pats| {
for pats.each |pat| {
check_pat(pcx, *pat, ty::mk_err());
}
@ -569,7 +569,7 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
for before.each |&elt| {
check_pat(pcx, elt, ty::mk_err());
}
for slice.each |&elt| {
for slice.iter().advance |&elt| {
check_pat(pcx, elt, ty::mk_err());
}
for after.each |&elt| {

6
src/librustc/middle/typeck/check/method.rs
View File

@ -332,14 +332,14 @@ impl<'self> LookupContext<'self> {
// candidates.
let trait_map: &mut resolve::TraitMap = &mut self.fcx.ccx.trait_map;
let opt_applicable_traits = trait_map.find(&self.expr.id);
for opt_applicable_traits.each |applicable_traits| {
for opt_applicable_traits.iter().advance |applicable_traits| {
for applicable_traits.each |trait_did| {
let coherence_info = self.fcx.ccx.coherence_info;
// Look for explicit implementations.
let opt_impl_infos =
coherence_info.extension_methods.find(trait_did);
for opt_impl_infos.each |impl_infos| {
for opt_impl_infos.iter().advance |impl_infos| {
for impl_infos.each |impl_info| {
self.push_candidates_from_impl(
self.extension_candidates, *impl_info);
@ -536,7 +536,7 @@ impl<'self> LookupContext<'self> {
pub fn push_inherent_impl_candidates_for_type(&self, did: def_id) {
let opt_impl_infos =
self.fcx.ccx.coherence_info.inherent_methods.find(&did);
for opt_impl_infos.each |impl_infos| {
for opt_impl_infos.iter().advance |impl_infos| {
for impl_infos.each |impl_info| {
self.push_candidates_from_impl(
self.inherent_candidates, *impl_info);

6
src/librustc/middle/typeck/check/mod.rs
View File

@ -410,7 +410,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
None => ()
}
for opt_self_info.each |self_info| {
for opt_self_info.iter().advance |self_info| {
fcx.write_ty(self_info.self_id, self_info.self_ty);
}
for decl.inputs.iter().zip(arg_tys.iter()).advance |(input, arg)| {
@ -442,7 +442,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
};
// Add the self parameter
for opt_self_info.each |self_info| {
for opt_self_info.iter().advance |self_info| {
assign(self_info.self_id, Some(self_info.self_ty));
debug!("self is assigned to %s",
fcx.infcx().ty_to_str(
@ -3092,7 +3092,7 @@ pub fn check_enum_variants(ccx: @mut CrateCtxt,
variants: &mut ~[ty::VariantInfo]) {
let rty = ty::node_id_to_type(ccx.tcx, id);
for vs.each |v| {
for v.node.disr_expr.each |e_ref| {
for v.node.disr_expr.iter().advance |e_ref| {
let e = *e_ref;
debug!("disr expr, checking %s",
pprust::expr_to_str(e, ccx.tcx.sess.intr()));

55
src/librustc/middle/typeck/check/regionck.rs
View File

@ -28,6 +28,7 @@ this point a bit better.
*/
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::freevars::get_freevars;
use middle::ty::{re_scope};
@ -268,7 +269,7 @@ fn visit_expr(expr: @ast::expr, rcx: @mut Rcx, v: rvt) {
ast::expr_match(_, ref arms) => {
tcx.region_maps.record_cleanup_scope(expr.id);
for arms.each |arm| {
for arm.guard.each |guard| {
for arm.guard.iter().advance |guard| {
tcx.region_maps.record_cleanup_scope(guard.id);
}
}
@ -281,26 +282,29 @@ fn visit_expr(expr: @ast::expr, rcx: @mut Rcx, v: rvt) {
}
// Check any autoderefs or autorefs that appear.
for rcx.fcx.inh.adjustments.find(&expr.id).each |&adjustment| {
debug!("adjustment=%?", adjustment);
match *adjustment {
@ty::AutoDerefRef(
ty::AutoDerefRef {autoderefs: autoderefs, autoref: opt_autoref}) =>
{
let expr_ty = rcx.resolve_node_type(expr.id);
constrain_derefs(rcx, expr, autoderefs, expr_ty);
for opt_autoref.each |autoref| {
guarantor::for_autoref(rcx, expr, autoderefs, autoref);
{
let r = rcx.fcx.inh.adjustments.find(&expr.id);
for r.iter().advance |&adjustment| {
debug!("adjustment=%?", adjustment);
match *adjustment {
@ty::AutoDerefRef(
ty::AutoDerefRef {autoderefs: autoderefs, autoref: opt_autoref}) =>
{
let expr_ty = rcx.resolve_node_type(expr.id);
constrain_derefs(rcx, expr, autoderefs, expr_ty);
for opt_autoref.iter().advance |autoref| {
guarantor::for_autoref(rcx, expr, autoderefs, autoref);
// Require that the resulting region encompasses
// the current node.
//
// FIXME(#6268) remove to support nested method calls
constrain_regions_in_type_of_node(
rcx, expr.id, ty::re_scope(expr.id), expr.span);
// Require that the resulting region encompasses
// the current node.
//
// FIXME(#6268) remove to support nested method calls
constrain_regions_in_type_of_node(
rcx, expr.id, ty::re_scope(expr.id), expr.span);
}
}
_ => {}
}
_ => {}
}
}
@ -489,7 +493,7 @@ fn constrain_call(rcx: @mut Rcx,
}
// as loop above, but for receiver
for receiver.each |&r| {
for receiver.iter().advance |&r| {
constrain_regions_in_type_of_node(
rcx, r.id, callee_region, r.span);
if implicitly_ref_args {
@ -871,9 +875,8 @@ pub mod guarantor {
rcx: @mut Rcx,
expr: @ast::expr,
sub_region: ty::Region,
sup_region: Option<ty::Region>)
{
for sup_region.each |r| {
sup_region: Option<ty::Region>) {
for sup_region.iter().advance |r| {
infallibly_mk_subr(rcx, true, expr.span, sub_region, *r);
}
}
@ -895,7 +898,7 @@ pub mod guarantor {
debug!("guarantor::for_by_ref(expr=%?, callee_scope=%?) category=%?",
expr.id, callee_scope, expr_cat);
let minimum_lifetime = ty::re_scope(callee_scope);
for expr_cat.guarantor.each |guarantor| {
for expr_cat.guarantor.iter().advance |guarantor| {
mk_subregion_due_to_derefence(rcx, expr.span,
minimum_lifetime, *guarantor);
}
@ -1201,12 +1204,12 @@ pub mod guarantor {
ast::pat_ident(ast::bind_by_ref(_), _, opt_p) => {
link(rcx, pat.span, pat.id, guarantor);
for opt_p.each |p| {
for opt_p.iter().advance |p| {
link_ref_bindings_in_pat(rcx, *p, guarantor);
}
}
ast::pat_ident(_, _, opt_p) => {
for opt_p.each |p| {
for opt_p.iter().advance |p| {
link_ref_bindings_in_pat(rcx, *p, guarantor);
}
}
@ -1245,7 +1248,7 @@ pub mod guarantor {
};
link_ref_bindings_in_pats(rcx, before, guarantor1);
for slice.each |&p| {
for slice.iter().advance |&p| {
link_ref_bindings_in_pat(rcx, p, guarantor);
}
link_ref_bindings_in_pats(rcx, after, guarantor1);

8
src/librustc/middle/typeck/check/regionmanip.rs
View File

@ -33,11 +33,11 @@ pub fn replace_bound_regions_in_fn_sig(
{
let mut all_tys = ty::tys_in_fn_sig(fn_sig);
for opt_self_ty.each |&self_ty| {
for opt_self_ty.iter().advance |&self_ty| {
all_tys.push(self_ty);
}
for opt_self_ty.each |&t| { all_tys.push(t) }
for opt_self_ty.iter().advance |&t| { all_tys.push(t) }
debug!("replace_bound_regions_in_fn_sig(self_ty=%?, fn_sig=%s, \
all_tys=%?)",
@ -200,7 +200,7 @@ pub fn relate_nested_regions(
*/
let mut the_stack = ~[];
for opt_region.each |&r| { the_stack.push(r); }
for opt_region.iter().advance |&r| { the_stack.push(r); }
walk_ty(tcx, &mut the_stack, ty, relate_op);
fn walk_ty(tcx: ty::ctxt,
@ -262,7 +262,7 @@ pub fn relate_free_regions(
for fn_sig.inputs.each |arg| {
all_tys.push(*arg);
}
for self_ty.each |&t| {
for self_ty.iter().advance |&t| {
all_tys.push(t);
}

5
src/librustc/middle/typeck/check/vtable.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::resolve::Impl;
use middle::ty::param_ty;
@ -273,8 +274,8 @@ fn lookup_vtable(vcx: &VtableContext,
// same trait as trait_ref, we need to
// unify it with trait_ref in order to get all
// the ty vars sorted out.
for ty::impl_trait_ref(tcx, im.did).each |&of_trait_ref|
{
let r = ty::impl_trait_ref(tcx, im.did);
for r.iter().advance |&of_trait_ref| {
if of_trait_ref.def_id != trait_ref.def_id { loop; }
// At this point, we know that of_trait_ref is

34
src/librustc/middle/typeck/check/writeback.rs
View File

@ -13,6 +13,7 @@
// substitutions.
use core::prelude::*;
use core::iterator::IteratorUtil;
use middle::pat_util;
use middle::ty;
@ -64,13 +65,16 @@ fn resolve_method_map_entry(fcx: @mut FnCtxt, sp: span, id: ast::node_id) {
match fcx.inh.method_map.find(&id) {
None => {}
Some(mme) => {
for resolve_type_vars_in_type(fcx, sp, mme.self_ty).each |t| {
let method_map = fcx.ccx.method_map;
let new_entry = method_map_entry { self_ty: *t, ..*mme };
debug!("writeback::resolve_method_map_entry(id=%?, \
new_entry=%?)",
id, new_entry);
method_map.insert(id, new_entry);
{
let r = resolve_type_vars_in_type(fcx, sp, mme.self_ty);
for r.iter().advance |t| {
let method_map = fcx.ccx.method_map;
let new_entry = method_map_entry { self_ty: *t, ..*mme };
debug!("writeback::resolve_method_map_entry(id=%?, \
new_entry=%?)",
id, new_entry);
method_map.insert(id, new_entry);
}
}
}
}
@ -220,13 +224,19 @@ fn visit_expr(e: @ast::expr, wbcx: @mut WbCtxt, v: wb_vt) {
resolve_type_vars_for_node(wbcx, e.span, e.id);
resolve_method_map_entry(wbcx.fcx, e.span, e.id);
for e.get_callee_id().each |callee_id| {
resolve_method_map_entry(wbcx.fcx, e.span, *callee_id);
{
let r = e.get_callee_id();
for r.iter().advance |callee_id| {
resolve_method_map_entry(wbcx.fcx, e.span, *callee_id);
}
}
resolve_vtable_map_entry(wbcx.fcx, e.span, e.id);
for e.get_callee_id().each |callee_id| {
resolve_vtable_map_entry(wbcx.fcx, e.span, *callee_id);
{
let r = e.get_callee_id();
for r.iter().advance |callee_id| {
resolve_vtable_map_entry(wbcx.fcx, e.span, *callee_id);
}
}
match e.node {
@ -327,7 +337,7 @@ pub fn resolve_type_vars_in_fn(fcx: @mut FnCtxt,
let wbcx = @mut WbCtxt { fcx: fcx, success: true };
let visit = mk_visitor();
(visit.visit_block)(blk, wbcx, visit);
for self_info.each |self_info| {
for self_info.iter().advance |self_info| {
resolve_type_vars_for_node(wbcx,
self_info.span,
self_info.self_id);

9
src/librustc/middle/typeck/coherence.rs
View File

@ -56,7 +56,6 @@ use util::ppaux::ty_to_str;
use core::iterator::IteratorUtil;
use core::hashmap::{HashMap, HashSet};
use core::old_iter;
use core::result::Ok;
use core::uint;
use core::vec;
@ -213,7 +212,7 @@ impl CoherenceChecker {
match item.node {
item_impl(_, opt_trait, _, _) => {
self.check_implementation(item,
old_iter::to_vec(&opt_trait));
opt_trait.iter().transform(|&x| x).collect());
}
_ => {
// Nothing to do.
@ -808,7 +807,7 @@ impl CoherenceChecker {
}
// Check that we have implementations of every trait method
for trait_refs.each |trait_ref| {
for trait_refs.iter().advance |trait_ref| {
let trait_did =
self.trait_ref_to_trait_def_id(*trait_ref);
self.please_check_that_trait_methods_are_implemented(
@ -821,7 +820,7 @@ impl CoherenceChecker {
// methods are provided. For each of those methods,
// if a method of that name is not inherent to the
// impl, use the provided definition in the trait.
for trait_refs.each |trait_ref| {
for trait_refs.iter().advance |trait_ref| {
let trait_did =
self.trait_ref_to_trait_def_id(*trait_ref);
@ -920,7 +919,7 @@ impl CoherenceChecker {
}
// Record all the trait methods.
for associated_traits.each |trait_ref| {
for associated_traits.iter().advance |trait_ref| {
self.add_trait_method(trait_ref.def_id, *implementation);
}

7
src/librustc/middle/typeck/collect.rs
View File

@ -31,6 +31,7 @@ are represented as `ty_param()` instances.
*/
use core::prelude::*;
use core::iterator::IteratorUtil;
use metadata::csearch;
use middle::ty::{substs, ty_param_bounds_and_ty};
@ -579,10 +580,10 @@ pub fn compare_impl_method(tcx: ty::ctxt,
// For both the trait and the impl, create an argument to
// represent the self argument (unless this is a static method).
// This argument will have the *transformed* self type.
for trait_m.transformed_self_ty.each |&t| {
for trait_m.transformed_self_ty.iter().advance |&t| {
trait_fn_args.push(t);
}
for impl_m.transformed_self_ty.each |&t| {
for impl_m.transformed_self_ty.iter().advance |&t| {
impl_fn_args.push(t);
}
@ -867,7 +868,7 @@ pub fn convert(ccx: &CrateCtxt, it: @ast::item) {
let cms = convert_methods(ccx, *ms, selfty,
&i_ty_generics, generics,
parent_visibility);
for opt_trait_ref.each |t| {
for opt_trait_ref.iter().advance |t| {
check_methods_against_trait(ccx, generics, rp, selfty, *t, cms);
}
}

3
src/librustc/middle/typeck/infer/mod.rs
View File

@ -269,6 +269,7 @@ use util::ppaux::{bound_region_to_str, ty_to_str, trait_ref_to_str};
use core::result;
use core::vec;
use core::iterator::IteratorUtil;
use extra::list::Nil;
use extra::smallintmap::SmallIntMap;
use syntax::ast::{m_imm, m_mutbl};
@ -766,7 +767,7 @@ impl InferCtxt {
fmt!("%s%s", mk_msg(Some(self.ty_to_str(e)), actual_ty), error_str));
}
}
for err.each |err| {
for err.iter().advance |err| {
ty::note_and_explain_type_err(self.tcx, *err)
}
}

3
src/librustc/util/ppaux.rs
View File

@ -32,6 +32,7 @@ use syntax::parse::token;
use syntax::print::pprust;
use syntax::{ast, ast_util};
use core::iterator::IteratorUtil;
use core::str;
use core::vec;
@ -798,7 +799,7 @@ impl UserString for ty::TraitRef {
let base = ast_map::path_to_str(path, tcx.sess.intr());
if tcx.sess.verbose() && self.substs.self_ty.is_some() {
let mut all_tps = copy self.substs.tps;
for self.substs.self_ty.each |&t| { all_tps.push(t); }
for self.substs.self_ty.iter().advance |&t| { all_tps.push(t); }
parameterized(tcx, base, self.substs.self_r, all_tps)
} else {
parameterized(tcx, base, self.substs.self_r,

2
src/librustpkg/package_source.rs
View File

@ -131,7 +131,7 @@ impl PkgSrc {
return true;
}
else {
for self_id.each |pth| {
for self_id.iter().advance |pth| {
if pth.starts_with("rust_") // because p is already normalized
&& match p.filestem() {
Some(s) => str::eq_slice(s, pth.slice(5, pth.len())),

4
src/librustpkg/rustpkg.rc
View File

@ -346,14 +346,14 @@ impl Ctx {
target_exec.to_str(), target_lib,
maybe_executable, maybe_library);
for maybe_executable.each |exec| {
for maybe_executable.iter().advance |exec| {
debug!("Copying: %s -> %s", exec.to_str(), target_exec.to_str());
if !(os::mkdir_recursive(&target_exec.dir_path(), u_rwx) &&
os::copy_file(exec, &target_exec)) {
cond.raise((copy *exec, copy target_exec));
}
}
for maybe_library.each |lib| {
for maybe_library.iter().advance |lib| {
let target_lib = (copy target_lib).expect(fmt!("I built %s but apparently \
didn't install it!", lib.to_str()));
debug!("Copying: %s -> %s", lib.to_str(), target_lib.to_str());

3
src/libstd/hashmap.rs
View File

@ -20,6 +20,7 @@ use cmp::{Eq, Equiv};
use hash::Hash;
use old_iter::BaseIter;
use old_iter;
use iterator::{Iterator, IteratorUtil};
use option::{None, Option, Some};
use rand::RngUtil;
use rand;
@ -316,7 +317,7 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
/// Visit all key-value pairs
fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) -> bool {
for self.buckets.each |bucket| {
for bucket.each |pair| {
for bucket.iter().advance |pair| {
if !blk(&pair.key, &pair.value) {
return false;
}

42
src/libstd/iterator.rs
View File

@ -49,12 +49,12 @@ pub trait IteratorUtil<A> {
///
/// let a = [0];
/// let b = [1];
/// let mut it = a.iter().chain(b.iter());
/// let mut it = a.iter().chain_(b.iter());
/// assert_eq!(it.next().get(), &0);
/// assert_eq!(it.next().get(), &1);
/// assert!(it.next().is_none());
/// ~~~
fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<A, Self, U>;
fn chain_<U: Iterator<A>>(self, other: U) -> ChainIterator<A, Self, U>;
/// Creates an iterator which iterates over both this and the specified
/// iterators simultaneously, yielding the two elements as pairs. When
@ -191,6 +191,7 @@ pub trait IteratorUtil<A> {
/// ~~~
fn skip(self, n: uint) -> SkipIterator<A, Self>;
// FIXME: #5898: should be called take
/// Creates an iterator which yields the first `n` elements of this
/// iterator, and then it will always return None.
///
@ -200,13 +201,13 @@ pub trait IteratorUtil<A> {
/// use std::iterator::*;
///
/// let a = [1, 2, 3, 4, 5];
/// let mut it = a.iter().take(3);
/// let mut it = a.iter().take_(3);
/// assert_eq!(it.next().get(), &1);
/// assert_eq!(it.next().get(), &2);
/// assert_eq!(it.next().get(), &3);
/// assert!(it.next().is_none());
/// ~~~
fn take(self, n: uint) -> TakeIterator<A, Self>;
fn take_(self, n: uint) -> TakeIterator<A, Self>;
/// Creates a new iterator which behaves in a similar fashion to foldl.
/// There is a state which is passed between each iteration and can be
@ -337,10 +338,10 @@ pub trait IteratorUtil<A> {
///
/// let a = [1, 2, 3, 4, 5];
/// let mut it = a.iter();
/// assert!(it.any(|&x| *x == 3));
/// assert!(!it.any(|&x| *x == 3));
/// assert!(it.any_(|&x| *x == 3));
/// assert!(!it.any_(|&x| *x == 3));
/// ~~~
fn any(&mut self, f: &fn(A) -> bool) -> bool;
fn any_(&mut self, f: &fn(A) -> bool) -> bool;
}
/// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
@ -349,7 +350,7 @@ pub trait IteratorUtil<A> {
/// In the future these will be default methods instead of a utility trait.
impl<A, T: Iterator<A>> IteratorUtil<A> for T {
#[inline(always)]
fn chain<U: Iterator<A>>(self, other: U) -> ChainIterator<A, T, U> {
fn chain_<U: Iterator<A>>(self, other: U) -> ChainIterator<A, T, U> {
ChainIterator{a: self, b: other, flag: false}
}
@ -394,8 +395,9 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
SkipIterator{iter: self, n: n}
}
// FIXME: #5898: should be called take
#[inline(always)]
fn take(self, n: uint) -> TakeIterator<A, T> {
fn take_(self, n: uint) -> TakeIterator<A, T> {
TakeIterator{iter: self, n: n}
}
@ -467,7 +469,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
}
#[inline(always)]
fn any(&mut self, f: &fn(A) -> bool) -> bool {
fn any_(&mut self, f: &fn(A) -> bool) -> bool {
for self.advance |x| { if f(x) { return true; } }
return false;
}
@ -878,7 +880,7 @@ mod tests {
#[test]
fn test_counter_from_iter() {
let mut it = Counter::new(0, 5).take(10);
let mut it = Counter::new(0, 5).take_(10);
let xs: ~[int] = iter::FromIter::from_iter::<int, ~[int]>(|f| it.advance(f));
assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
}
@ -888,7 +890,7 @@ mod tests {
let xs = [0u, 1, 2, 3, 4, 5];
let ys = [30u, 40, 50, 60];
let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
let mut it = xs.iter().chain(ys.iter());
let mut it = xs.iter().chain_(ys.iter());
let mut i = 0;
for it.advance |&x| {
assert_eq!(x, expected[i]);
@ -896,8 +898,8 @@ mod tests {
}
assert_eq!(i, expected.len());
let ys = Counter::new(30u, 10).take(4);
let mut it = xs.iter().transform(|&x| x).chain(ys);
let ys = Counter::new(30u, 10).take_(4);
let mut it = xs.iter().transform(|&x| x).chain_(ys);
let mut i = 0;
for it.advance |x| {
assert_eq!(x, expected[i]);
@ -908,7 +910,7 @@ mod tests {
#[test]
fn test_filter_map() {
let mut it = Counter::new(0u, 1u).take(10)
let mut it = Counter::new(0u, 1u).take_(10)
.filter_map(|x| if x.is_even() { Some(x*x) } else { None });
assert_eq!(it.collect::<~[uint]>(), ~[0*0, 2*2, 4*4, 6*6, 8*8]);
}
@ -965,7 +967,7 @@ mod tests {
fn test_iterator_take() {
let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
let ys = [0u, 1, 2, 3, 5];
let mut it = xs.iter().take(5);
let mut it = xs.iter().take_(5);
let mut i = 0;
for it.advance |&x| {
assert_eq!(x, ys[i]);
@ -1088,9 +1090,9 @@ mod tests {
#[test]
fn test_any() {
let v = ~&[1, 2, 3, 4, 5];
assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x.is_even()));
assert!(!v.iter().any(|&x| x > 100));
assert!(!v.slice(0, 0).iter().any(|_| fail!()));
assert!(v.iter().any_(|&x| x < 10));
assert!(v.iter().any_(|&x| x.is_even()));
assert!(!v.iter().any_(|&x| x > 100));
assert!(!v.slice(0, 0).iter().any_(|_| fail!()));
}
}

92
src/libstd/option.rs
View File

@ -46,12 +46,12 @@ use ops::Add;
use kinds::Copy;
use util;
use num::Zero;
use old_iter::{BaseIter, MutableIter, ExtendedIter};
use old_iter;
use iterator::Iterator;
use str::StrSlice;
use clone::DeepClone;
#[cfg(test)] use str;
#[cfg(test)] use iterator::IteratorUtil;
/// The option type
#[deriving(Clone, DeepClone, Eq)]
@ -100,53 +100,27 @@ impl<T: Copy + Add<T,T>> Add<Option<T>, Option<T>> for Option<T> {
}
}
impl<T> BaseIter<T> for Option<T> {
/// Performs an operation on the contained value by reference
#[inline(always)]
fn each<'a>(&'a self, f: &fn(x: &'a T) -> bool) -> bool {
match *self { None => true, Some(ref t) => { f(t) } }
}
#[inline(always)]
fn size_hint(&self) -> Option<uint> {
if self.is_some() { Some(1) } else { Some(0) }
}
}
impl<T> MutableIter<T> for Option<T> {
#[inline(always)]
fn each_mut<'a>(&'a mut self, f: &fn(&'a mut T) -> bool) -> bool {
match *self { None => true, Some(ref mut t) => { f(t) } }
}
}
impl<A> ExtendedIter<A> for Option<A> {
pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
old_iter::eachi(self, blk)
}
pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::all(self, blk)
}
pub fn any(&self, blk: &fn(&A) -> bool) -> bool {
old_iter::any(self, blk)
}
pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B {
old_iter::foldl(self, b0, blk)
}
pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> {
old_iter::position(self, f)
}
fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] {
old_iter::map_to_vec(self, op)
}
fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB)
-> ~[B] {
old_iter::flat_map_to_vec(self, op)
}
}
impl<T> Option<T> {
/// Return an iterator over the possibly contained value
#[inline]
pub fn iter<'r>(&'r self) -> OptionIterator<'r, T> {
match *self {
Some(ref x) => OptionIterator{opt: Some(x)},
None => OptionIterator{opt: None}
}
}
/// Return a mutable iterator over the possibly contained value
#[inline]
pub fn mut_iter<'r>(&'r mut self) -> OptionMutIterator<'r, T> {
match *self {
Some(ref mut x) => OptionMutIterator{opt: Some(x)},
None => OptionMutIterator{opt: None}
}
}
/// Returns true if the option equals `none`
#[inline]
pub fn is_none(&const self) -> bool {
match *self { None => true, Some(_) => false }
}
@ -376,6 +350,28 @@ impl<T:Copy + Zero> Option<T> {
}
}
/// Immutable iterator over an `Option<A>`
pub struct OptionIterator<'self, A> {
priv opt: Option<&'self A>
}
impl<'self, A> Iterator<&'self A> for OptionIterator<'self, A> {
fn next(&mut self) -> Option<&'self A> {
util::replace(&mut self.opt, None)
}
}
/// Mutable iterator over an `Option<A>`
pub struct OptionMutIterator<'self, A> {
priv opt: Option<&'self mut A>
}
impl<'self, A> Iterator<&'self mut A> for OptionMutIterator<'self, A> {
fn next(&mut self) -> Option<&'self mut A> {
util::replace(&mut self.opt, None)
}
}
#[test]
fn test_unwrap_ptr() {
unsafe {
@ -429,7 +425,7 @@ fn test_option_dance() {
let x = Some(());
let mut y = Some(5);
let mut y2 = 0;
for x.each |_x| {
for x.iter().advance |_x| {
y2 = y.swap_unwrap();
}
assert_eq!(y2, 5);

2
src/libstd/os.rs
View File

@ -1574,7 +1574,7 @@ mod tests {
setenv("HOME", "");
assert!(os::homedir().is_none());
for oldhome.each |s| { setenv("HOME", *s) }
for oldhome.iter().advance |s| { setenv("HOME", *s) }
}
#[test]

12
src/libstd/run.rs
View File

@ -176,9 +176,9 @@ impl Process {
in_fd, out_fd, err_fd);
unsafe {
for in_pipe.each |pipe| { libc::close(pipe.in); }
for out_pipe.each |pipe| { libc::close(pipe.out); }
for err_pipe.each |pipe| { libc::close(pipe.out); }
for in_pipe.iter().advance |pipe| { libc::close(pipe.in); }
for out_pipe.iter().advance |pipe| { libc::close(pipe.out); }
for err_pipe.iter().advance |pipe| { libc::close(pipe.out); }
}
Process {
@ -323,7 +323,7 @@ impl Process {
* If the child has already been finished then the exit code is returned.
*/
pub fn finish(&mut self) -> int {
for self.exit_code.each |&code| {
for self.exit_code.iter().advance |&code| {
return code;
}
self.close_input();
@ -523,7 +523,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
CloseHandle(si.hStdOutput);
CloseHandle(si.hStdError);
for create_err.each |msg| {
for create_err.iter().advance |msg| {
fail!("failure in CreateProcess: %s", *msg);
}
@ -589,7 +589,7 @@ pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
return cmd;
fn append_arg(cmd: &mut ~str, arg: &str) {
let quote = arg.iter().any(|c| c == ' ' || c == '\t');
let quote = arg.iter().any_(|c| c == ' ' || c == '\t');
if quote {
cmd.push_char('"');
}

7
src/libstd/task/spawn.rs
View File

@ -92,6 +92,7 @@ use uint;
use util;
use unstable::sync::{Exclusive, exclusive};
use rt::local::Local;
use iterator::{Iterator, IteratorUtil};
#[cfg(test)] use task::default_task_opts;
#[cfg(test)] use comm;
@ -276,7 +277,7 @@ fn each_ancestor(list: &mut AncestorList,
* Step 3: Maybe unwind; compute return info for our caller.
*##########################################################*/
if need_unwind && !nobe_is_dead {
for bail_opt.each |bail_blk| {
for bail_opt.iter().advance |bail_blk| {
do with_parent_tg(&mut nobe.parent_group) |tg_opt| {
(*bail_blk)(tg_opt)
}
@ -328,7 +329,7 @@ impl Drop for TCB {
// If we are failing, the whole taskgroup needs to die.
if rt::rust_task_is_unwinding(self.me) {
for this.notifier.each_mut |x| {
for this.notifier.mut_iter().advance |x| {
x.failed = true;
}
// Take everybody down with us.
@ -357,7 +358,7 @@ fn TCB(me: *rust_task,
ancestors: AncestorList,
is_main: bool,
mut notifier: Option<AutoNotify>) -> TCB {
for notifier.each_mut |x| {
for notifier.mut_iter().advance |x| {
x.failed = false;
}

12
src/libstd/unstable/extfmt.rs
View File

@ -76,8 +76,8 @@ debug!("hello, %s!", "world");
*/
use cmp::Eq;
use prelude::*;
use iterator::IteratorUtil;
/*
* We have a 'ct' (compile-time) module that parses format strings into a
@ -607,7 +607,7 @@ pub mod rt {
let headsize = match head { Some(_) => 1, _ => 0 };
let uwidth : uint = match cv.width {
CountImplied => {
for head.each |&c| {
for head.iter().advance |&c| {
buf.push_char(c);
}
return buf.push_str(s);
@ -616,7 +616,7 @@ pub mod rt {
};
let strlen = str::char_len(s) + headsize;
if uwidth <= strlen {
for head.each |&c| {
for head.iter().advance |&c| {
buf.push_char(c);
}
return buf.push_str(s);
@ -624,7 +624,7 @@ pub mod rt {
let mut padchar = ' ';
let diff = uwidth - strlen;
if have_flag(cv.flags, flag_left_justify) {
for head.each |&c| {
for head.iter().advance |&c| {
buf.push_char(c);
}
buf.push_str(s);
@ -658,7 +658,7 @@ pub mod rt {
// instead.
if signed && zero_padding {
for head.each |&head| {
for head.iter().advance |&head| {
if head == '+' || head == '-' || head == ' ' {
buf.push_char(head);
buf.push_str(padstr);
@ -668,7 +668,7 @@ pub mod rt {
}
}
buf.push_str(padstr);
for head.each |&c| {
for head.iter().advance |&c| {
buf.push_char(c);
}
buf.push_str(s);

8
src/libsyntax/ast_map.rs
View File

@ -22,6 +22,7 @@ use print::pprust;
use visit;
use syntax::parse::token::special_idents;
use core::iterator::IteratorUtil;
use core::cmp;
use core::hashmap::HashMap;
use core::vec;
@ -317,8 +318,11 @@ pub fn map_struct_def(
pub fn map_expr(ex: @expr, cx: @mut Ctx, v: visit::vt<@mut Ctx>) {
cx.map.insert(ex.id, node_expr(ex));
// Expressions which are or might be calls:
for ex.get_callee_id().each |callee_id| {
cx.map.insert(*callee_id, node_callee_scope(ex));
{
let r = ex.get_callee_id();
for r.iter().advance |callee_id| {
cx.map.insert(*callee_id, node_callee_scope(ex));
}
}
visit::visit_expr(ex, cx, v);
}

12
src/libsyntax/ast_util.rs
View File

@ -24,6 +24,7 @@ use core::hashmap::HashMap;
use core::int;
use core::option;
use core::to_bytes;
use core::iterator::IteratorUtil;
pub fn path_name_i(idents: &[ident]) -> ~str {
// FIXME: Bad copies (#2543 -- same for everything else that says "bad")
@ -461,8 +462,11 @@ pub fn id_visitor<T: Copy>(vfn: @fn(node_id, T)) -> visit::vt<T> {
},
visit_expr: |e, t, vt| {
for e.get_callee_id().each |callee_id| {
vfn(*callee_id, t);
{
let r = e.get_callee_id();
for r.iter().advance |callee_id| {
vfn(*callee_id, t);
}
}
vfn(e.id, t);
visit::visit_expr(e, t, vt);
@ -553,8 +557,8 @@ pub fn walk_pat(pat: @pat, it: &fn(@pat) -> bool) -> bool {
}
pat_vec(ref before, ref slice, ref after) => {
before.each(|&p| walk_pat(p, it)) &&
slice.each(|&p| walk_pat(p, it)) &&
after.each(|&p| walk_pat(p, it))
slice.iter().advance(|&p| walk_pat(p, it)) &&
after.iter().advance(|&p| walk_pat(p, it))
}
pat_wild | pat_lit(_) | pat_range(_, _) | pat_ident(_, _, _) |
pat_enum(_, _) => {

3
src/libsyntax/diagnostic.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use core::prelude::*;
use core::iterator::IteratorUtil;
use codemap::{Pos, span};
use codemap;
@ -304,7 +305,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
}
fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
for sp.expn_info.each |ei| {
for sp.expn_info.iter().advance |ei| {
let ss = ei.callee.span.map_default(@~"", |span| @cm.span_to_str(*span));
print_diagnostic(*ss, note,
fmt!("in expansion of %s!", ei.callee.name));

4
src/libsyntax/ext/expand.rs
View File

@ -384,7 +384,9 @@ pub fn new_name_finder() -> @Visitor<@mut ~[ast::ident]> {
_ => ()
}
// visit optional subpattern of pat_ident:
for inner.each |subpat: &@ast::pat| { (v.visit_pat)(*subpat, ident_accum, v) }
for inner.iter().advance |subpat: &@ast::pat| {
(v.visit_pat)(*subpat, ident_accum, v)
}
}
// use the default traversal for non-pat_idents
_ => visit::visit_pat(p,ident_accum,v)

17
src/libsyntax/print/pprust.rs
View File

@ -34,6 +34,7 @@ use core::io;
use core::str;
use core::u64;
use core::uint;
use core::iterator::IteratorUtil;
// The @ps is stored here to prevent recursive type.
pub enum ann_node<'self> {
@ -371,7 +372,7 @@ pub fn print_foreign_mod(s: @ps, nmod: &ast::foreign_mod,
}
pub fn print_opt_lifetime(s: @ps, lifetime: Option<@ast::Lifetime>) {
for lifetime.each |l| {
for lifetime.iter().advance |l| {
print_lifetime(s, *l);
nbsp(s);
}
@ -1213,7 +1214,7 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
print_block(s, blk);
}
ast::expr_loop(ref blk, opt_ident) => {
for opt_ident.each |ident| {
for opt_ident.iter().advance |ident| {
word(s.s, "'");
print_ident(s, *ident);
word_space(s, ":");
@ -1362,7 +1363,7 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
ast::expr_break(opt_ident) => {
word(s.s, "break");
space(s.s);
for opt_ident.each |ident| {
for opt_ident.iter().advance |ident| {
word(s.s, "'");
print_ident(s, *ident);
space(s.s);
@ -1371,7 +1372,7 @@ pub fn print_expr(s: @ps, expr: @ast::expr) {
ast::expr_again(opt_ident) => {
word(s.s, "loop");
space(s.s);
for opt_ident.each |ident| {
for opt_ident.iter().advance |ident| {
word(s.s, "'");
print_ident(s, *ident);
space(s.s)
@ -1498,7 +1499,7 @@ pub fn print_path(s: @ps, path: @ast::Path, colons_before_params: bool) {
if path.rp.is_some() || !path.types.is_empty() {
word(s.s, "<");
for path.rp.each |r| {
for path.rp.iter().advance |r| {
print_lifetime(s, *r);
if !path.types.is_empty() {
word_space(s, ",");
@ -1613,7 +1614,7 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) {
do commasep(s, inconsistent, *before) |s, p| {
print_pat(s, p, refutable);
}
for slice.each |&p| {
for slice.iter().advance |&p| {
if !before.is_empty() { word_space(s, ","); }
word(s.s, "..");
print_pat(s, p, refutable);
@ -1675,7 +1676,7 @@ pub fn print_fn_args(s: @ps, decl: &ast::fn_decl,
// self type and the args all in the same box.
box(s, 0u, inconsistent);
let mut first = true;
for opt_explicit_self.each |explicit_self| {
for opt_explicit_self.iter().advance |explicit_self| {
first = !print_explicit_self(s, *explicit_self);
}
@ -1922,7 +1923,7 @@ pub fn print_ty_fn(s: @ps,
// self type and the args all in the same box.
box(s, 0u, inconsistent);
let mut first = true;
for opt_explicit_self.each |explicit_self| {
for opt_explicit_self.iter().advance |explicit_self| {
first = !print_explicit_self(s, *explicit_self);
}
for decl.inputs.each |arg| {

15
src/libsyntax/visit.rs
View File

@ -9,6 +9,7 @@
// except according to those terms.
use core::prelude::*;
use core::iterator::IteratorUtil;
use abi::AbiSet;
use ast::*;
@ -189,7 +190,7 @@ pub fn visit_item<E: Copy>(i: @item, e: E, v: vt<E>) {
}
item_impl(ref tps, ref traits, ty, ref methods) => {
(v.visit_generics)(tps, e, v);
for traits.each |&p| {
for traits.iter().advance |&p| {
visit_trait_ref(p, e, v);
}
(v.visit_ty)(ty, e, v);
@ -227,7 +228,7 @@ pub fn visit_enum_def<E: Copy>(enum_definition: &ast::enum_def,
}
}
// Visit the disr expr if it exists
for vr.node.disr_expr.each |ex| { (v.visit_expr)(*ex, e, v) }
for vr.node.disr_expr.iter().advance |ex| { (v.visit_expr)(*ex, e, v) }
}
}
@ -269,8 +270,8 @@ pub fn visit_pat<E: Copy>(p: @pat, e: E, v: vt<E>) {
match p.node {
pat_enum(path, ref children) => {
visit_path(path, e, v);
for children.each |children| {
for children.each |child| { (v.visit_pat)(*child, e, v); }
for children.iter().advance |children| {
for children.iter().advance |child| { (v.visit_pat)(*child, e, v); }
}
}
pat_struct(path, ref fields, _) => {
@ -289,7 +290,7 @@ pub fn visit_pat<E: Copy>(p: @pat, e: E, v: vt<E>) {
},
pat_ident(_, path, ref inner) => {
visit_path(path, e, v);
for inner.each |subpat| { (v.visit_pat)(*subpat, e, v) }
for inner.iter().advance |subpat| { (v.visit_pat)(*subpat, e, v) }
}
pat_lit(ex) => (v.visit_expr)(ex, e, v),
pat_range(e1, e2) => {
@ -301,7 +302,7 @@ pub fn visit_pat<E: Copy>(p: @pat, e: E, v: vt<E>) {
for before.each |elt| {
(v.visit_pat)(*elt, e, v);
}
for slice.each |elt| {
for slice.iter().advance |elt| {
(v.visit_pat)(*elt, e, v);
}
for after.each |tail| {
@ -550,7 +551,7 @@ pub fn visit_expr<E: Copy>(ex: @expr, e: E, v: vt<E>) {
}
pub fn visit_arm<E: Copy>(a: &arm, e: E, v: vt<E>) {
for a.pats.each |p| { (v.visit_pat)(*p, e, v); }
for a.pats.iter().advance |p| { (v.visit_pat)(*p, e, v); }
visit_expr_opt(a.guard, e, v);
(v.visit_block)(&a.body, e, v);
}

4
src/test/bench/graph500-bfs.rs
View File

@ -112,7 +112,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] {
while keys.len() < n {
let k = r.gen_uint_range(0u, graph.len());
if graph[k].len() > 0u && graph[k].iter().any(|i| {
if graph[k].len() > 0u && graph[k].iter().any_(|i| {
*i != k as node_id
}) {
keys.insert(k as node_id);
@ -188,7 +188,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
}
let mut i = 0;
while colors.iter().any(is_gray) {
while colors.iter().any_(is_gray) {
// Do the BFS.
info!("PBFS iteration %?", i);
i += 1;

12
src/test/run-pass/block-arg.rs
View File

@ -21,20 +21,20 @@ pub fn main() {
}
// Usable at all:
let mut any_negative = do v.iter().any |e| { e.is_negative() };
let mut any_negative = do v.iter().any_ |e| { e.is_negative() };
assert!(any_negative);
// Higher precedence than assignments:
any_negative = do v.iter().any |e| { e.is_negative() };
any_negative = do v.iter().any_ |e| { e.is_negative() };
assert!(any_negative);
// Higher precedence than unary operations:
let abs_v = do vec::map(v) |e| { e.abs() };
assert!(do abs_v.iter().all |e| { e.is_positive() });
assert!(!do abs_v.iter().any |e| { e.is_negative() });
assert!(!do abs_v.iter().any_ |e| { e.is_negative() });
// Usable in funny statement-like forms:
if !do v.iter().any |e| { e.is_positive() } {
if !do v.iter().any_ |e| { e.is_positive() } {
assert!(false);
}
match do v.iter().all |e| { e.is_negative() } {
@ -42,7 +42,7 @@ pub fn main() {
false => { }
}
match 3 {
_ if do v.iter().any |e| { e.is_negative() } => {
_ if do v.iter().any_ |e| { e.is_negative() } => {
}
_ => {
fail!("wrong answer.");
@ -59,7 +59,7 @@ pub fn main() {
// In the tail of a block
let w =
if true { do abs_v.iter().any |e| { e.is_positive() } }
if true { do abs_v.iter().any_ |e| { e.is_positive() } }
else { false };
assert!(w);
}

7
src/test/run-pass/early-vtbl-resolution.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
trait thing<A> {
fn foo(&self) -> Option<A>;
}
@ -21,10 +19,5 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
struct A { a: int }
pub fn main() {
for old_iter::eachi(&(Some(A {a: 0}))) |i, a| {
debug!("%u %d", i, a.a);
}
let _x: Option<float> = foo_func(0);
}

23
src/test/run-pass/iter-all.rs
View File

@ -1,23 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
pub fn main() {
assert!(![1u, 2u].all(is_even));
assert!([2u, 4u].all(is_even));
assert!([].all(is_even));
assert!(!old_iter::all(&Some(1u), is_even));
assert!(old_iter::all(&Some(2u), is_even));
assert!(old_iter::all(&None::<uint>, is_even));
}

23
src/test/run-pass/iter-any.rs
View File

@ -1,23 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
pub fn main() {
assert!(![1u, 3u].any(is_even));
assert!([1u, 2u].any(is_even));
assert!(![].any(is_even));
assert!(!old_iter::any(&Some(1u), is_even));
assert!(old_iter::any(&Some(2u), is_even));
assert!(!old_iter::any(&None::<uint>, is_even));
}

22
src/test/run-pass/iter-contains.rs
View File

@ -1,22 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
pub fn main() {
assert_eq!([].contains(&22u), false);
assert_eq!([1u, 3u].contains(&22u), false);
assert_eq!([22u, 1u, 3u].contains(&22u), true);
assert_eq!([1u, 22u, 3u].contains(&22u), true);
assert_eq!([1u, 3u, 22u].contains(&22u), true);
assert_eq!(old_iter::contains(&None::<uint>, &22u), false);
assert_eq!(old_iter::contains(&Some(1u), &22u), false);
assert_eq!(old_iter::contains(&Some(22u), &22u), true);
}

21
src/test/run-pass/iter-count.rs
View File

@ -1,21 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
pub fn main() {
assert_eq!([].count(&22u), 0u);
assert_eq!([1u, 3u].count(&22u), 0u);
assert_eq!([22u, 1u, 3u].count(&22u), 1u);
assert_eq!([22u, 1u, 22u].count(&22u), 2u);
assert_eq!(old_iter::count(&None::<uint>, &22u), 0u);
assert_eq!(old_iter::count(&Some(1u), &22u), 0u);
assert_eq!(old_iter::count(&Some(22u), &22u), 1u);
}

29
src/test/run-pass/iter-eachi.rs
View File

@ -1,29 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
pub fn main() {
let mut c = 0u;
for [1u, 2u, 3u, 4u, 5u].eachi |i, v| {
assert_eq!((i + 1u), *v);
c += 1u;
}
assert_eq!(c, 5u);
for old_iter::eachi(&None::<uint>) |i, v| { fail!(); }
let mut c = 0u;
for old_iter::eachi(&Some(1u)) |i, v| {
assert_eq!((i + 1u), *v);
c += 1u;
}
assert_eq!(c, 1u);
}

21
src/test/run-pass/iter-filter-to-vec.rs
View File

@ -1,21 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
pub fn main() {
assert_eq!([1, 3].filter_to_vec(is_even), ~[]);
assert_eq!([1, 2, 3].filter_to_vec(is_even), ~[2]);
assert_eq!(old_iter::filter_to_vec(&None::<uint>, is_even), ~[]);
assert_eq!(old_iter::filter_to_vec(&Some(1u), is_even), ~[]);
assert_eq!(old_iter::filter_to_vec(&Some(2u), is_even), ~[2]);
}

31
src/test/run-pass/iter-flat-map-to-vec.rs
View File

@ -1,31 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn repeat(x: &uint) -> ~[uint] { ~[*x, *x] }
fn incd_if_even(x: &uint) -> Option<uint> {
if (*x % 2u) == 0u {Some(*x + 1u)} else {None}
}
pub fn main() {
assert_eq!((~[1u, 3u]).flat_map_to_vec(repeat), ~[1u, 1u, 3u, 3u]);
assert_eq!((~[]).flat_map_to_vec(repeat), ~[]);
assert_eq!(old_iter::flat_map_to_vec(&None::<uint>, repeat), ~[]);
assert_eq!(old_iter::flat_map_to_vec(&Some(1u), repeat), ~[1u, 1u]);
assert_eq!(old_iter::flat_map_to_vec(&Some(2u), repeat), ~[2u, 2u]);
assert_eq!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even), ~[3u]);
assert_eq!((~[]).flat_map_to_vec(incd_if_even), ~[]);
assert_eq!(old_iter::flat_map_to_vec(&None::<uint>, incd_if_even), ~[]);
assert_eq!(old_iter::flat_map_to_vec(&Some(1u), incd_if_even), ~[]);
assert_eq!(old_iter::flat_map_to_vec(&Some(2u), incd_if_even), ~[3u]);
}

21
src/test/run-pass/iter-foldl.rs
View File

@ -1,21 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
pub fn main() {
assert_eq!([1u, 3u].foldl(20f, add), 24f);
assert_eq!([].foldl(20f, add), 20f);
assert_eq!(old_iter::foldl(&None::<uint>, 20f, add), 20f);
assert_eq!(old_iter::foldl(&Some(1u), 20f, add), 21f);
assert_eq!(old_iter::foldl(&Some(2u), 20f, add), 22f);
}

21
src/test/run-pass/iter-map-to-vec.rs
View File

@ -1,21 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn inc(x: &uint) -> uint { *x + 1 }
pub fn main() {
assert_eq!([1, 3].map_to_vec(inc), ~[2, 4]);
assert_eq!([1, 2, 3].map_to_vec(inc), ~[2, 3, 4]);
assert_eq!(old_iter::map_to_vec(&None::<uint>, inc), ~[]);
assert_eq!(old_iter::map_to_vec(&Some(1u), inc), ~[2]);
assert_eq!(old_iter::map_to_vec(&Some(2u), inc), ~[3]);
}

23
src/test/run-pass/iter-min-max.rs
View File

@ -1,23 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
fn is_even(x: uint) -> bool { (x % 2u) == 0u }
pub fn main() {
assert_eq!([1u, 3u].min(), 1u);
assert_eq!([3u, 1u].min(), 1u);
assert_eq!(old_iter::min(&Some(1u)), 1u);
assert_eq!([1u, 3u].max(), 3u);
assert_eq!([3u, 1u].max(), 3u);
assert_eq!(old_iter::max(&Some(3u)), 3u);
}

20
src/test/run-pass/iter-to-vec.rs
View File

@ -1,20 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::old_iter;
pub fn main() {
assert_eq!([1u, 3u].to_vec(), ~[1u, 3u]);
let e: ~[uint] = ~[];
assert_eq!(e.to_vec(), ~[]);
assert_eq!(old_iter::to_vec(&None::<uint>), ~[]);
assert_eq!(old_iter::to_vec(&Some(1u)), ~[1u]);
assert_eq!(old_iter::to_vec(&Some(2u)), ~[2u]);
}

4
src/test/run-pass/test-ignore-cfg.rs
View File

@ -31,8 +31,8 @@ fn checktests() {
let tests = __test::tests;
assert!(
tests.iter().any(|t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore));
tests.iter().any_(|t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore));
assert!(
tests.iter().any(|t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore));
tests.iter().any_(|t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore));
}