diff options
68 files changed, 787 insertions, 843 deletions
diff --git a/doc/tutorial-container.md b/doc/tutorial-container.md index b7465ddb4df..19cd58bd3b4 100644 --- a/doc/tutorial-container.md +++ b/doc/tutorial-container.md @@ -164,19 +164,18 @@ dropped when they become unnecessary. ## For loops -The `foreach` keyword is transitional, and is going to replace the current -obsolete `for` loop. +The `for` keyword can be used as sugar for iterating through any iterator: ~~~ let xs = [2, 3, 5, 7, 11, 13, 17]; // print out all the elements in the vector -foreach x in xs.iter() { +for x in xs.iter() { println(x.to_str()) } // print out all but the first 3 elements in the vector -foreach x in xs.iter().skip(3) { +for x in xs.iter().skip(3) { println(x.to_str()) } ~~~ @@ -192,7 +191,7 @@ let ys = ["foo", "bar", "baz", "foobar"]; let mut it = xs.iter().zip(ys.iter()); // print out the pairs of elements up to (&3, &"baz") -foreach (x, y) in it { +for (x, y) in it { printfln!("%d %s", *x, *y); if *x == 3 { @@ -229,7 +228,7 @@ impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] { pub fn from_iterator(iterator: &mut T) -> ~[A] { let (lower, _) = iterator.size_hint(); let mut xs = with_capacity(lower); - foreach x in iterator { + for x in iterator { xs.push(x); } xs @@ -300,7 +299,7 @@ printfln!("%?", it.next()); // prints `Some(&2)` printfln!("%?", it.next_back()); // prints `Some(&6)` // prints `5`, `4` and `3` -foreach &x in it.invert() { +for &x in it.invert() { printfln!("%?", x) } ~~~ @@ -319,7 +318,7 @@ let mut it = xs.iter().chain_(ys.iter()).transform(|&x| x * 2); printfln!("%?", it.next()); // prints `Some(2)` // prints `16`, `14`, `12`, `10`, `8`, `6`, `4` -foreach x in it.invert() { +for x in it.invert() { printfln!("%?", x); } ~~~ diff --git a/doc/tutorial.md b/doc/tutorial.md index 89c3fa0bcae..a5f2001eaf5 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -567,11 +567,6 @@ loop { This code prints out a weird sequence of numbers and stops as soon as it finds one that can be divided by five. -Rust also has a `for` construct. It's different from C's `for` and it works -best when iterating over collections. See the section on [closures](#closures) -to find out how to use `for` and higher-order functions for enumerating -elements of a collection. - # Data structures ## Structs @@ -1397,8 +1392,8 @@ assert!(crayons.len() == 3); assert!(!crayons.is_empty()); // Iterate over a vector, obtaining a pointer to each element -// (`for` is explained in the next section) -foreach crayon in crayons.iter() { +// (`for` is explained in the container/iterator tutorial) +for crayon in crayons.iter() { let delicious_crayon_wax = unwrap_crayon(*crayon); eat_crayon_wax(delicious_crayon_wax); } @@ -1749,7 +1744,7 @@ of `vector`: ~~~~ fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] { let mut accumulator = ~[]; - foreach element in vector.iter() { + for element in vector.iter() { accumulator.push(function(element)); } return accumulator; @@ -2027,7 +2022,7 @@ generic types. ~~~~ # trait Printable { fn print(&self); } fn print_all<T: Printable>(printable_things: ~[T]) { - foreach thing in printable_things.iter() { + for thing in printable_things.iter() { thing.print(); } } @@ -2073,7 +2068,7 @@ However, consider this function: trait Drawable { fn draw(&self); } fn draw_all<T: Drawable>(shapes: ~[T]) { - foreach shape in shapes.iter() { shape.draw(); } + for shape in shapes.iter() { shape.draw(); } } # let c: Circle = new_circle(); # draw_all(~[c]); @@ -2088,7 +2083,7 @@ an _object_. ~~~~ # trait Drawable { fn draw(&self); } fn draw_all(shapes: &[@Drawable]) { - foreach shape in shapes.iter() { shape.draw(); } + for shape in shapes.iter() { shape.draw(); } } ~~~~ diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 0860219e1a9..a07da151afc 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -41,7 +41,7 @@ pub fn load_props(testfile: &Path) -> TestProps { let mut pp_exact = None; let mut debugger_cmds = ~[]; let mut check_lines = ~[]; - for iter_header(testfile) |ln| { + do iter_header(testfile) |ln| { match parse_error_pattern(ln) { Some(ep) => error_patterns.push(ep), None => () @@ -74,6 +74,8 @@ pub fn load_props(testfile: &Path) -> TestProps { Some(cl) => check_lines.push(cl), None => () }; + + true }; return TestProps { error_patterns: error_patterns, @@ -87,17 +89,19 @@ pub fn load_props(testfile: &Path) -> TestProps { } pub fn is_test_ignored(config: &config, testfile: &Path) -> bool { - for iter_header(testfile) |ln| { - if parse_name_directive(ln, "xfail-test") { return true; } - if parse_name_directive(ln, xfail_target()) { return true; } - if config.mode == common::mode_pretty && - parse_name_directive(ln, "xfail-pretty") { return true; } - }; - return false; - fn xfail_target() -> ~str { ~"xfail-" + os::SYSNAME } + + let val = do iter_header(testfile) |ln| { + if parse_name_directive(ln, "xfail-test") { false } + else if parse_name_directive(ln, xfail_target()) { false } + else if config.mode == common::mode_pretty && + parse_name_directive(ln, "xfail-pretty") { false } + else { true } + }; + + !val } fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool { @@ -109,7 +113,7 @@ fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool { // module or function. This doesn't seem to be an optimization // with a warm page cache. Maybe with a cold one. if ln.starts_with("fn") || ln.starts_with("mod") { - return false; + return true; } else { if !(it(ln)) { return false; } } } return true; diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs index 834faf96eb6..7a71d3f667f 100644 --- a/src/libextra/bitv.rs +++ b/src/libextra/bitv.rs @@ -206,13 +206,14 @@ impl BigBitv { #[inline] pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool { let len = b.storage.len(); - for uint::iterate(0, len) |i| { + do uint::iterate(0, len) |i| { let mask = big_mask(nbits, i); if mask & self.storage[i] != mask & b.storage[i] { - return false; + false + } else { + true } } - return true; } } @@ -358,7 +359,7 @@ impl Bitv { pub fn clear(&mut self) { match self.rep { Small(ref mut b) => b.clear(), - Big(ref mut s) => for s.each_storage() |w| { *w = 0u } + Big(ref mut s) => { do s.each_storage() |w| { *w = 0u; true }; } } } @@ -367,7 +368,8 @@ impl Bitv { pub fn set_all(&mut self) { match self.rep { Small(ref mut b) => b.set_all(), - Big(ref mut s) => for s.each_storage() |w| { *w = !0u } } + Big(ref mut s) => { do s.each_storage() |w| { *w = !0u; true }; } + } } /// Invert all bits @@ -375,7 +377,8 @@ impl Bitv { pub fn negate(&mut self) { match self.rep { Small(ref mut b) => b.negate(), - Big(ref mut s) => for s.each_storage() |w| { *w = !*w } } + Big(ref mut s) => { do s.each_storage() |w| { *w = !*w; true }; } + } } /** @@ -718,11 +721,11 @@ impl BitvSet { } pub fn difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) -> bool { - for self.common_iter(other).advance |(i, w1, w2)| { + foreach (i, w1, w2) in self.common_iter(other) { if !iterate_bits(i, w1 & !w2, |b| f(&b)) { - return false; + return false } - } + }; /* everything we have that they don't also shows up */ self.outlier_iter(other).advance(|(mine, i, w)| !mine || iterate_bits(i, w, |b| f(&b)) @@ -731,11 +734,11 @@ impl BitvSet { pub fn symmetric_difference(&self, other: &BitvSet, f: &fn(&uint) -> bool) -> bool { - for self.common_iter(other).advance |(i, w1, w2)| { + foreach (i, w1, w2) in self.common_iter(other) { if !iterate_bits(i, w1 ^ w2, |b| f(&b)) { - return false; + return false } - } + }; self.outlier_iter(other).advance(|(_, i, w)| iterate_bits(i, w, |b| f(&b))) } @@ -744,11 +747,11 @@ impl BitvSet { } pub fn union(&self, other: &BitvSet, f: &fn(&uint) -> bool) -> bool { - for self.common_iter(other).advance |(i, w1, w2)| { + foreach (i, w1, w2) in self.common_iter(other) { if !iterate_bits(i, w1 | w2, |b| f(&b)) { - return false; + return false } - } + }; self.outlier_iter(other).advance(|(_, i, w)| iterate_bits(i, w, |b| f(&b))) } } @@ -758,12 +761,12 @@ impl cmp::Eq for BitvSet { if self.size != other.size { return false; } - for self.common_iter(other).advance |(_, w1, w2)| { + foreach (_, w1, w2) in self.common_iter(other) { if w1 != w2 { return false; } } - for self.outlier_iter(other).advance |(_, _, w)| { + foreach (_, _, w) in self.outlier_iter(other) { if w != 0 { return false; } @@ -798,7 +801,7 @@ impl Set<uint> for BitvSet { } fn is_subset(&self, other: &BitvSet) -> bool { - for self.common_iter(other).advance |(_, w1, w2)| { + foreach (_, w1, w2) in self.common_iter(other) { if w1 & w2 != w1 { return false; } @@ -806,7 +809,7 @@ impl Set<uint> for BitvSet { /* If anything is not ours, then everything is not ours so we're definitely a subset in that case. Otherwise if there's any stray ones that 'other' doesn't have, we're not a subset. */ - for self.outlier_iter(other).advance |(mine, _, w)| { + foreach (mine, _, w) in self.outlier_iter(other) { if !mine { return true; } else if w != 0 { diff --git a/src/libextra/crypto/sha2.rs b/src/libextra/crypto/sha2.rs index d92a4be43c3..06e96d99bca 100644 --- a/src/libextra/crypto/sha2.rs +++ b/src/libextra/crypto/sha2.rs @@ -112,7 +112,7 @@ impl Engine512State { // Putting the message schedule inside the same loop as the round calculations allows for // the compiler to generate better code. - for uint::range_step(0, 64, 8) |t| { + do uint::range_step(0, 64, 8) |t| { schedule_round!(t + 16); schedule_round!(t + 17); schedule_round!(t + 18); @@ -130,9 +130,10 @@ impl Engine512State { sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5); sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6); sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7); - } + true + }; - for uint::range_step(64, 80, 8) |t| { + do uint::range_step(64, 80, 8) |t| { sha2_round!(a, b, c, d, e, f, g, h, K64, t); sha2_round!(h, a, b, c, d, e, f, g, K64, t + 1); sha2_round!(g, h, a, b, c, d, e, f, K64, t + 2); @@ -141,7 +142,8 @@ impl Engine512State { sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5); sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6); sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7); - } + true + }; self.H0 += a; self.H1 += b; @@ -507,7 +509,7 @@ impl Engine256State { // Putting the message schedule inside the same loop as the round calculations allows for // the compiler to generate better code. - for uint::range_step(0, 48, 8) |t| { + do uint::range_step(0, 48, 8) |t| { schedule_round!(t + 16); schedule_round!(t + 17); schedule_round!(t + 18); @@ -525,9 +527,10 @@ impl Engine256State { sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5); sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6); sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7); - } + true + }; - for uint::range_step(48, 64, 8) |t| { + do uint::range_step(48, 64, 8) |t| { sha2_round!(a, b, c, d, e, f, g, h, K32, t); sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1); sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2); @@ -536,7 +539,8 @@ impl Engine256State { sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5); sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6); sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7); - } + true + }; self.H0 += a; self.H1 += b; diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs index 0de8c239d56..2094259664c 100644 --- a/src/libextra/fileinput.rs +++ b/src/libextra/fileinput.rs @@ -505,9 +505,10 @@ mod test { } let mut read_lines = ~[]; - for input_vec(filenames) |line| { + do input_vec(filenames) |line| { read_lines.push(line.to_owned()); - } + true + }; assert_eq!(read_lines, all_lines); } @@ -523,13 +524,14 @@ mod test { make_file(filename.get_ref(), contents); } - for input_vec_state(filenames) |line, state| { + do input_vec_state(filenames) |line, state| { let nums: ~[&str] = line.split_iter(' ').collect(); let file_num = uint::from_str(nums[0]).get(); let line_num = uint::from_str(nums[1]).get(); assert_eq!(line_num, state.line_num_file); assert_eq!(file_num * 3 + line_num, state.line_num); - } + true + }; } #[test] @@ -543,7 +545,7 @@ mod test { make_file(filenames[2].get_ref(), [~"3", ~"4"]); let mut count = 0; - for input_vec_state(filenames.clone()) |line, state| { + do input_vec_state(filenames.clone()) |line, state| { let expected_path = match line { "1" | "2" => filenames[0].clone(), "3" | "4" => filenames[2].clone(), @@ -551,7 +553,8 @@ mod test { }; assert_eq!(state.current_path.clone(), expected_path); count += 1; - } + true + }; assert_eq!(count, 4); } @@ -570,9 +573,10 @@ mod test { wr.write_str("3\n4"); let mut lines = ~[]; - for input_vec(~[f1, f2]) |line| { + do input_vec(~[f1, f2]) |line| { lines.push(line.to_owned()); - } + true + }; assert_eq!(lines, ~[~"1", ~"2", ~"3", ~"4"]); } @@ -610,8 +614,9 @@ mod test { #[test] #[should_fail] fn test_input_vec_missing_file() { - for input_vec(pathify([~"this/file/doesnt/exist"], true)) |line| { + do input_vec(pathify([~"this/file/doesnt/exist"], true)) |line| { println(line); - } + true + }; } } diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index e939f42ac90..8b8e3faaf9a 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -155,13 +155,12 @@ impl<V> SmallIntMap<V> { /// Visit all key-value pairs in reverse order pub fn each_reverse<'a>(&'a self, it: &fn(uint, &'a V) -> bool) -> bool { - for uint::range_rev(self.v.len(), 0) |i| { + do uint::range_rev(self.v.len(), 0) |i| { match self.v[i] { - Some(ref elt) => if !it(i, elt) { return false; }, - None => () + Some(ref elt) => it(i, elt), + None => true } } - return true; } pub fn get<'a>(&'a self, key: &uint) -> &'a V { diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index b69b2f8067d..9a681bf6a07 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -148,7 +148,7 @@ struct crate_hash { pub fn get_dep_hashes(cstore: &CStore) -> ~[@str] { let mut result = ~[]; - for cstore.extern_mod_crate_map.each_value |&cnum| { + foreach (_, &cnum) in cstore.extern_mod_crate_map.iter() { let cdata = cstore::get_crate_data(cstore, cnum); let hash = decoder::get_crate_hash(cdata.data); let vers = decoder::get_crate_vers(cdata.data); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 60867585248..4824fe55f1d 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -60,13 +60,18 @@ fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: uint) -> let tagged_doc = reader::doc_at(d.data, pos); let belt = tag_index_buckets_bucket_elt; - for reader::tagged_docs(tagged_doc.doc, belt) |elt| { + + let mut ret = None; + do reader::tagged_docs(tagged_doc.doc, belt) |elt| { let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint; if eq_fn(elt.data.slice(elt.start + 4u, elt.end)) { - return Some(reader::doc_at(d.data, pos).doc); + ret = Some(reader::doc_at(d.data, pos).doc); + false + } else { + true } }; - None + ret } pub type GetCrateDataCb<'self> = &'self fn(ast::CrateNum) -> cmd; @@ -160,10 +165,12 @@ fn item_visibility(item: ebml::Doc) -> ast::visibility { } fn item_method_sort(item: ebml::Doc) -> char { - for reader::tagged_docs(item, tag_item_trait_method_sort) |doc| { - return doc.as_str_slice()[0] as char; - } - return 'r'; + let mut ret = 'r'; + do reader::tagged_docs(item, tag_item_trait_method_sort) |doc| { + ret = doc.as_str_slice()[0] as char; + false + }; + ret } fn item_symbol(item: ebml::Doc) -> ~str { @@ -171,10 +178,12 @@ fn item_symbol(item: ebml::Doc) -> ~str { } fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> { - for reader::tagged_docs(d, tag_items_data_parent_item) |did| { - return Some(reader::with_doc_data(did, parse_def_id)); - } - None + let mut ret = None; + do reader::tagged_docs(d, tag_items_data_parent_item) |did| { + ret = Some(reader::with_doc_data(did, parse_def_id)); + false + }; + ret } fn item_reqd_and_translated_parent_item(cnum: ast::CrateNum, @@ -195,12 +204,7 @@ fn get_provided_source(d: ebml::Doc, cdata: cmd) -> Option<ast::def_id> { } fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool { - for reader::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| { - if !f(reexport_doc) { - return false; - } - } - return true; + reader::tagged_docs(d, tag_items_data_item_reexport, f) } fn variant_disr_val(d: ebml::Doc) -> Option<uint> { @@ -250,12 +254,13 @@ fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd, tag: uint) -> @~[ty::TypeParameterDef] { let mut bounds = ~[]; - for reader::tagged_docs(item, tag) |p| { + do reader::tagged_docs(item, tag) |p| { let bd = parse_type_param_def_data( *p.data, p.start, cdata.cnum, tcx, |_, did| translate_def_id(cdata, did)); bounds.push(bd); - } + true + }; @bounds } @@ -276,9 +281,10 @@ fn item_ty_param_count(item: ebml::Doc) -> uint { fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] { let mut ids: ~[ast::def_id] = ~[]; let v = tag_items_data_item_variant; - for reader::tagged_docs(item, v) |p| { + do reader::tagged_docs(item, v) |p| { let ext = reader::with_doc_data(p, parse_def_id); ids.push(ast::def_id { crate: cdata.cnum, node: ext.node }); + true }; return ids; } @@ -290,7 +296,7 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path { let len = reader::doc_as_u32(len_doc) as uint; let mut result = vec::with_capacity(len); - for reader::docs(path_doc) |tag, elt_doc| { + do reader::docs(path_doc) |tag, elt_doc| { if tag == tag_path_elt_mod { let str = elt_doc.as_str_slice(); result.push(ast_map::path_mod(token::str_to_ident(str))); @@ -300,7 +306,8 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path { } else { // ignore tag_path_len element } - } + true + }; return result; } @@ -432,13 +439,13 @@ pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::NodeId, name: ast::ident) -> Option<ast::def_id> { let items = reader::get_doc(reader::Doc(cdata.data), tag_items); let mut found = None; - for reader::tagged_docs(find_item(id, items), tag_item_impl_method) - |mid| { - let m_did = reader::with_doc_data(mid, parse_def_id); - if item_name(intr, find_item(m_did.node, items)) == name { - found = Some(translate_def_id(cdata, m_did)); - } + do reader::tagged_docs(find_item(id, items), tag_item_impl_method) |mid| { + let m_did = reader::with_doc_data(mid, parse_def_id); + if item_name(intr, find_item(m_did.node, items)) == name { + found = Some(translate_def_id(cdata, m_did)); } + true + }; found } @@ -465,18 +472,15 @@ fn def_like_to_def(def_like: def_like) -> ast::def { pub fn each_lang_item(cdata: cmd, f: &fn(ast::NodeId, uint) -> bool) -> bool { let root = reader::Doc(cdata.data); let lang_items = reader::get_doc(root, tag_lang_items); - for reader::tagged_docs(lang_items, tag_lang_items_item) |item_doc| { + do reader::tagged_docs(lang_items, tag_lang_items_item) |item_doc| { let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id); let id = reader::doc_as_u32(id_doc) as uint; let node_id_doc = reader::get_doc(item_doc, tag_lang_items_item_node_id); let node_id = reader::doc_as_u32(node_id_doc) as ast::NodeId; - if !f(node_id, id) { - return false; - } + f(node_id, id) } - return true; } struct EachItemContext<'self> { @@ -581,7 +585,7 @@ impl<'self> EachItemContext<'self> { let mut continue = true; // Iterate over all children. - for reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| { + do reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| { let child_def_id = reader::with_doc_data(child_info_doc, parse_def_id); let child_def_id = translate_def_id(self.cdata, child_def_id); @@ -621,20 +625,17 @@ impl<'self> EachItemContext<'self> { continue = self.process_item_and_pop_name(child_item_doc, child_def_id, old_len); - - if !continue { - break - } } } - } + continue + }; if !continue { return false } // Iterate over reexports. - for each_reexport(item_doc) |reexport_doc| { + do each_reexport(item_doc) |reexport_doc| { let def_id_doc = reader::get_doc( reexport_doc, tag_items_data_item_reexport_def_id); @@ -678,10 +679,8 @@ impl<'self> EachItemContext<'self> { } } - if !continue { - break - } - } + continue + }; continue } @@ -824,10 +823,11 @@ fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ { fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc, tcx: ty::ctxt) -> ~[@ty::Method] { let mut rslt = ~[]; - for reader::tagged_docs(item, tag_item_impl_method) |doc| { + do reader::tagged_docs(item, tag_item_impl_method) |doc| { let m_did = reader::with_doc_data(doc, parse_def_id); rslt.push(@get_method(intr, cdata, m_did.node, tcx)); - } + true + }; rslt } @@ -896,9 +896,10 @@ pub fn get_trait_method_def_ids(cdata: cmd, let data = cdata.data; let item = lookup_item(id, data); let mut result = ~[]; - for reader::tagged_docs(item, tag_item_trait_method) |mth| { + do reader::tagged_docs(item, tag_item_trait_method) |mth| { result.push(item_def_id(mth, cdata)); - } + true + }; result } @@ -909,14 +910,15 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd, let item = lookup_item(id, data); let mut result = ~[]; - for reader::tagged_docs(item, tag_item_trait_method) |mth_id| { + do reader::tagged_docs(item, tag_item_trait_method) |mth_id| { let did = item_def_id(mth_id, cdata); let mth = lookup_item(did.node, data); - if item_method_sort(mth) != 'p' { loop; } - - result.push(@get_method(intr, cdata, did.node, tcx)); - } + if item_method_sort(mth) == 'p' { + result.push(@get_method(intr, cdata, did.node, tcx)); + } + true + }; return result; } @@ -926,9 +928,10 @@ pub fn get_supertraits(cdata: cmd, id: ast::NodeId, tcx: ty::ctxt) -> ~[@ty::TraitRef] { let mut results = ~[]; let item_doc = lookup_item(id, cdata.data); - for reader::tagged_docs(item_doc, tag_item_super_trait_ref) |trait_doc| { + do reader::tagged_docs(item_doc, tag_item_super_trait_ref) |trait_doc| { results.push(@doc_trait_ref(trait_doc, tcx, cdata)); - } + true + }; return results; } @@ -939,11 +942,13 @@ pub fn get_type_name_if_impl(cdata: cmd, return None; } - for reader::tagged_docs(item, tag_item_impl_type_basename) |doc| { - return Some(token::str_to_ident(doc.as_str_slice())); - } + let mut ret = None; + do reader::tagged_docs(item, tag_item_impl_type_basename) |doc| { + ret = Some(token::str_to_ident(doc.as_str_slice())); + false + }; - return None; + ret } pub fn get_static_methods_if_impl(intr: @ident_interner, @@ -956,14 +961,17 @@ pub fn get_static_methods_if_impl(intr: @ident_interner, } // If this impl implements a trait, don't consider it. - for reader::tagged_docs(item, tag_item_trait_ref) |_doc| { - return None; - } + let ret = do reader::tagged_docs(item, tag_item_trait_ref) |_doc| { + false + }; + + if !ret { return None } let mut impl_method_ids = ~[]; - for reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| { + do reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| { impl_method_ids.push(reader::with_doc_data(impl_method_doc, parse_def_id)); - } + true + }; let mut static_impl_methods = ~[]; foreach impl_method_id in impl_method_ids.iter() { @@ -996,11 +1004,13 @@ pub fn get_item_attrs(cdata: cmd, f: &fn(~[@ast::MetaItem])) { let item = lookup_item(node_id, cdata.data); - for reader::tagged_docs(item, tag_attributes) |attributes| { - for reader::tagged_docs(attributes, tag_attribute) |attribute| { + do reader::tagged_docs(item, tag_attributes) |attributes| { + do reader::tagged_docs(attributes, tag_attribute) |attribute| { f(get_meta_items(attribute)); - } - } + true + }; + true + }; } fn struct_field_family_to_visibility(family: Family) -> ast::visibility { @@ -1017,7 +1027,7 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::NodeId) let data = cdata.data; let item = lookup_item(id, data); let mut result = ~[]; - for reader::tagged_docs(item, tag_item_field) |an_item| { + do reader::tagged_docs(item, tag_item_field) |an_item| { let f = item_family(an_item); if f == PublicField || f == PrivateField || f == InheritedField { let name = item_name(intr, an_item); @@ -1028,15 +1038,17 @@ pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::NodeId) struct_field_family_to_visibility(f), }); } - } - for reader::tagged_docs(item, tag_item_unnamed_field) |an_item| { + true + }; + do reader::tagged_docs(item, tag_item_unnamed_field) |an_item| { let did = item_def_id(an_item, cdata); result.push(ty::field_ty { ident: special_idents::unnamed_field, id: did, vis: ast::inherited, }); - } + true + }; result } @@ -1102,12 +1114,13 @@ fn item_family_to_str(fam: Family) -> ~str { fn get_meta_items(md: ebml::Doc) -> ~[@ast::MetaItem] { let mut items: ~[@ast::MetaItem] = ~[]; - for reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| { + do reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); let n = nd.as_str_slice().to_managed(); items.push(attr::mk_word_item(n)); + true }; - for reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| { + do reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); let vd = reader::get_doc(meta_item_doc, tag_meta_item_value); let n = nd.as_str_slice().to_managed(); @@ -1115,12 +1128,14 @@ fn get_meta_items(md: ebml::Doc) -> ~[@ast::MetaItem] { // FIXME (#623): Should be able to decode MetaNameValue variants, // but currently the encoder just drops them items.push(attr::mk_name_value_item_str(n, v)); + true }; - for reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| { + do reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| { let nd = reader::get_doc(meta_item_doc, tag_meta_item_name); let n = nd.as_str_slice().to_managed(); let subitems = get_meta_items(meta_item_doc); items.push(attr::mk_list_item(n, subitems)); + true }; return items; } @@ -1129,7 +1144,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::Attribute] { let mut attrs: ~[ast::Attribute] = ~[]; match reader::maybe_get_doc(md, tag_attributes) { option::Some(attrs_d) => { - for reader::tagged_docs(attrs_d, tag_attribute) |attr_doc| { + do reader::tagged_docs(attrs_d, tag_attribute) |attr_doc| { let meta_items = get_meta_items(attr_doc); // Currently it's only possible to have a single meta item on // an attribute @@ -1144,6 +1159,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::Attribute] { }, span: codemap::dummy_sp() }); + true }; } option::None => () @@ -1193,12 +1209,13 @@ pub fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] { let d = reader::get_doc(doc, tag_); d.as_str_slice().to_managed() } - for reader::tagged_docs(depsdoc, tag_crate_dep) |depdoc| { + do reader::tagged_docs(depsdoc, tag_crate_dep) |depdoc| { deps.push(crate_dep {cnum: crate_num, name: token::str_to_ident(docstr(depdoc, tag_crate_dep_name)), vers: docstr(depdoc, tag_crate_dep_vers), hash: docstr(depdoc, tag_crate_dep_hash)}); crate_num += 1; + true }; return deps; } @@ -1235,7 +1252,7 @@ pub fn get_crate_vers(data: @~[u8]) -> @str { fn iter_crate_items(intr: @ident_interner, cdata: cmd, get_crate_data: GetCrateDataCb, proc: &fn(path: &str, ast::def_id)) { - for each_path(intr, cdata, get_crate_data) |path_string, def_like, _| { + do each_path(intr, cdata, get_crate_data) |path_string, def_like, _| { match def_like { dl_impl(*) | dl_field => {} dl_def(def) => { @@ -1243,7 +1260,8 @@ fn iter_crate_items(intr: @ident_interner, cdata: cmd, ast_util::def_id_of_def(def)) } } - } + true + }; } pub fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8], @@ -1273,8 +1291,9 @@ pub fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id { pub fn get_link_args_for_crate(cdata: cmd) -> ~[~str] { let link_args = reader::get_doc(reader::Doc(cdata.data), tag_link_args); let mut result = ~[]; - for reader::tagged_docs(link_args, tag_link_args_arg) |arg_doc| { + do reader::tagged_docs(link_args, tag_link_args_arg) |arg_doc| { result.push(arg_doc.as_str()); - } + true + }; result } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 8374fe1df0d..74a3ba57543 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -558,11 +558,12 @@ fn encode_info_for_mod(ecx: &EncodeContext, ebml_w.wr_str(def_to_str(local_def(item.id))); ebml_w.end_tag(); - for each_auxiliary_node_id(*item) |auxiliary_node_id| { + do each_auxiliary_node_id(*item) |auxiliary_node_id| { ebml_w.start_tag(tag_mod_child); ebml_w.wr_str(def_to_str(local_def(auxiliary_node_id))); ebml_w.end_tag(); - } + true + }; match item.node { item_impl(*) => { @@ -1377,9 +1378,7 @@ fn synthesize_crate_attrs(ecx: &EncodeContext, let mut meta_items = ~[name_item, vers_item]; - for items.iter() - .filter(|mi| "name" != mi.name() && "vers" != mi.name()) - .advance |&mi| { + foreach &mi in items.iter().filter(|mi| "name" != mi.name() && "vers" != mi.name()) { meta_items.push(mi); } let link_item = attr::mk_list_item(@"link", meta_items); @@ -1454,26 +1453,24 @@ fn encode_crate_deps(ecx: &EncodeContext, fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) { ebml_w.start_tag(tag_lang_items); - for ecx.tcx.lang_items.each_item |def_id, i| { - let def_id = match def_id { - Some(id) => id, None => { loop } - }; - if def_id.crate != LOCAL_CRATE { - loop; - } - - ebml_w.start_tag(tag_lang_items_item); + do ecx.tcx.lang_items.each_item |def_id, i| { + foreach id in def_id.iter() { + if id.crate == LOCAL_CRATE { + ebml_w.start_tag(tag_lang_items_item); - ebml_w.start_tag(tag_lang_items_item_id); - ebml_w.writer.write_be_u32(i as u32); - ebml_w.end_tag(); // tag_lang_items_item_id + ebml_w.start_tag(tag_lang_items_item_id); + ebml_w.writer.write_be_u32(i as u32); + ebml_w.end_tag(); // tag_lang_items_item_id - ebml_w.start_tag(tag_lang_items_item_node_id); - ebml_w.writer.write_be_u32(def_id.node as u32); - ebml_w.end_tag(); // tag_lang_items_item_node_id + ebml_w.start_tag(tag_lang_items_item_node_id); + ebml_w.writer.write_be_u32(id.node as u32); + ebml_w.end_tag(); // tag_lang_items_item_node_id - ebml_w.end_tag(); // tag_lang_items_item - } + ebml_w.end_tag(); // tag_lang_items_item + } + } + true + }; ebml_w.end_tag(); // tag_lang_items } @@ -1501,11 +1498,12 @@ fn encode_misc_info(ecx: &EncodeContext, ebml_w.wr_str(def_to_str(local_def(item.id))); ebml_w.end_tag(); - for each_auxiliary_node_id(item) |auxiliary_node_id| { + do each_auxiliary_node_id(item) |auxiliary_node_id| { ebml_w.start_tag(tag_mod_child); ebml_w.wr_str(def_to_str(local_def(auxiliary_node_id))); ebml_w.end_tag(); - } + true + }; } // Encode reexports for the root module. diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 9891adc3b1b..765bf35b2b7 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -88,7 +88,7 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>, pub fn search<T>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> { let mut rslt = None; - for filesearch.for_each_lib_search_path() |lib_search_path| { + do filesearch.for_each_lib_search_path() |lib_search_path| { debug!("searching %s", lib_search_path.to_str()); let r = os::list_dir_path(lib_search_path); foreach path in r.iter() { @@ -102,8 +102,8 @@ pub fn search<T>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> { debug!("rejected %s", path.to_str()); } } - if rslt.is_some() { break; } - } + rslt.is_none() + }; return rslt; } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index b80af865e43..f8fae5ce26b 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -371,10 +371,11 @@ fn enc_purity(w: @io::Writer, p: purity) { fn enc_abi_set(w: @io::Writer, abis: AbiSet) { w.write_char('['); - for abis.each |abi| { + do abis.each |abi| { w.write_str(abi.name()); w.write_char(','); - } + true + }; w.write_char(']') } @@ -412,14 +413,15 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) { } fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) { - for bs.builtin_bounds.each |bound| { + do bs.builtin_bounds.each |bound| { match bound { ty::BoundSend => w.write_char('S'), ty::BoundFreeze => w.write_char('K'), ty::BoundStatic => w.write_char('O'), ty::BoundSized => w.write_char('Z'), } - } + true + }; foreach &tp in bs.trait_bounds.iter() { w.write_char('I'); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 310d8ffe0d6..902ff02e5d3 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1139,7 +1139,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext, ast_doc: ebml::Doc) { let dcx = xcx.dcx; let tbl_doc = ast_doc.get(c::tag_table as uint); - for reader::docs(tbl_doc) |tag, entry_doc| { + do reader::docs(tbl_doc) |tag, entry_doc| { let id0 = entry_doc.get(c::tag_table_id as uint).as_int(); let id = xcx.tr_id(id0); @@ -1218,7 +1218,8 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext, } debug!(">< Side table doc loaded"); - } + true + }; } // ______________________________________________________________________ diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 5ed2335192a..f6cc102938a 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -83,13 +83,10 @@ impl<'self> CheckLoanCtxt<'self> { //! are issued for future scopes and thus they may have been //! *issued* but not yet be in effect. - for self.dfcx_loans.each_bit_on_entry_frozen(scope_id) |loan_index| { + do self.dfcx_loans.each_bit_on_entry_frozen(scope_id) |loan_index| { let loan = &self.all_loans[loan_index]; - if !op(loan) { - return false; - } + op(loan) } - return true; } pub fn each_in_scope_loan(&self, @@ -100,14 +97,13 @@ impl<'self> CheckLoanCtxt<'self> { //! currently in scope. let region_maps = self.tcx().region_maps; - for self.each_issued_loan(scope_id) |loan| { + do self.each_issued_loan(scope_id) |loan| { if region_maps.is_subscope_of(scope_id, loan.kill_scope) { - if !op(loan) { - return false; - } + op(loan) + } else { + true } } - return true; } pub fn each_in_scope_restriction(&self, @@ -118,16 +114,18 @@ impl<'self> CheckLoanCtxt<'self> { //! Iterates through all the in-scope restrictions for the //! given `loan_path` - for self.each_in_scope_loan(scope_id) |loan| { + do self.each_in_scope_loan(scope_id) |loan| { + let mut ret = true; foreach restr in loan.restrictions.iter() { if restr.loan_path == loan_path { if !op(loan, restr) { - return false; + ret = false; + break; } } } + ret } - return true; } pub fn loans_generated_by(&self, scope_id: ast::NodeId) -> ~[uint] { @@ -135,9 +133,10 @@ impl<'self> CheckLoanCtxt<'self> { //! we encounter `scope_id`. let mut result = ~[]; - for self.dfcx_loans.each_gen_bit_frozen(scope_id) |loan_index| { + do self.dfcx_loans.each_gen_bit_frozen(scope_id) |loan_index| { result.push(loan_index); - } + true + }; return result; } @@ -152,12 +151,13 @@ impl<'self> CheckLoanCtxt<'self> { let new_loan_indices = self.loans_generated_by(scope_id); debug!("new_loan_indices = %?", new_loan_indices); - for self.each_issued_loan(scope_id) |issued_loan| { + do self.each_issued_loan(scope_id) |issued_loan| { foreach &new_loan_index in new_loan_indices.iter() { let new_loan = &self.all_loans[new_loan_index]; self.report_error_if_loans_conflict(issued_loan, new_loan); } - } + true + }; foreach i in range(0u, new_loan_indices.len()) { let old_loan = &self.all_loans[new_loan_indices[i]]; @@ -268,15 +268,15 @@ impl<'self> CheckLoanCtxt<'self> { debug!("check_if_path_is_moved(id=%?, use_kind=%?, lp=%s)", id, use_kind, lp.repr(self.bccx.tcx)); - for self.move_data.each_move_of(id, lp) |move, moved_lp| { + do self.move_data.each_move_of(id, lp) |move, moved_lp| { self.bccx.report_use_of_moved_value( span, use_kind, lp, move, moved_lp); - return; - } + false + }; } pub fn check_assignment(&self, expr: @ast::expr) { @@ -308,13 +308,13 @@ impl<'self> CheckLoanCtxt<'self> { if self.is_local_variable(cmt) { assert!(cmt.mutbl.is_immutable()); // no "const" locals let lp = opt_loan_path(cmt).get(); - for self.move_data.each_assignment_of(expr.id, lp) |assign| { + do self.move_data.each_assignment_of(expr.id, lp) |assign| { self.bccx.report_reassigned_immutable_variable( expr.span, lp, assign); - return; - } + false + }; return; } @@ -462,14 +462,18 @@ impl<'self> CheckLoanCtxt<'self> { // `RESTR_MUTATE` restriction whenever the contents of an // owned pointer are borrowed, and hence while `v[*]` is not // restricted from being written, `v` is. - for this.each_in_scope_restriction(expr.id, loan_path) + let cont = do this.each_in_scope_restriction(expr.id, loan_path) |loan, restr| { if restr.set.intersects(RESTR_MUTATE) { this.report_illegal_mutation(expr, loan_path, loan); - return false; + false + } else { + true } - } + }; + + if !cont { return false } // The previous code handled assignments to paths that // have been restricted. This covers paths that have been @@ -525,12 +529,16 @@ impl<'self> CheckLoanCtxt<'self> { } // Check for a non-const loan of `loan_path` - for this.each_in_scope_loan(expr.id) |loan| { + let cont = do this.each_in_scope_loan(expr.id) |loan| { if loan.loan_path == loan_path && loan.mutbl != m_const { this.report_illegal_mutation(expr, full_loan_path, loan); - return false; + false + } else { + true } - } + }; + + if !cont { return false } } } } @@ -563,7 +571,7 @@ impl<'self> CheckLoanCtxt<'self> { } fn check_move_out_from_id(&self, id: ast::NodeId, span: span) { - for self.move_data.each_path_moved_by(id) |_, move_path| { + do self.move_data.each_path_moved_by(id) |_, move_path| { match self.analyze_move_out_from(id, move_path) { MoveOk => {} MoveWhileBorrowed(loan_path, loan_span) => { @@ -578,7 +586,8 @@ impl<'self> CheckLoanCtxt<'self> { self.bccx.loan_path_to_str(loan_path))); } } - } + true + }; } pub fn analyze_move_out_from(&self, @@ -589,13 +598,16 @@ impl<'self> CheckLoanCtxt<'self> { // FIXME(#4384) inadequare if/when we permit `move a.b` + let mut ret = MoveOk; + // check for a conflicting loan: - for self.each_in_scope_restriction(expr_id, move_path) |loan, _| { + do self.each_in_scope_restriction(expr_id, move_path) |loan, _| { // Any restriction prevents moves. - return MoveWhileBorrowed(loan.loan_path, loan.span); - } + ret = MoveWhileBorrowed(loan.loan_path, loan.span); + false + }; - MoveOk + ret } pub fn check_call(&self, diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 07c8b7ad06c..9285c1e1f64 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -277,9 +277,10 @@ impl MoveData { match self.path_map.find_copy(&lp) { Some(index) => { - for self.each_base_path(index) |p| { + do self.each_base_path(index) |p| { result.push(p); - } + true + }; } None => { match *lp { @@ -446,25 +447,29 @@ impl MoveData { fn each_applicable_move(&self, index0: MovePathIndex, f: &fn(MoveIndex) -> bool) -> bool { - for self.each_extending_path(index0) |index| { + let mut ret = true; + do self.each_extending_path(index0) |index| { let mut p = self.path(index).first_move; while p != InvalidMoveIndex { if !f(p) { - return false; + ret = false; + break; } p = self.move(p).next_move; } - } - return true; + ret + }; + ret } fn kill_moves(&self, path: MovePathIndex, kill_id: ast::NodeId, dfcx_moves: &mut MoveDataFlow) { - for self.each_applicable_move(path) |move_index| { + do self.each_applicable_move(path) |move_index| { dfcx_moves.add_kill(kill_id, *move_index); - } + true + }; } } @@ -506,14 +511,11 @@ impl FlowedMoveData { * Iterates through each path moved by `id` */ - for self.dfcx_moves.each_gen_bit_frozen(id) |index| { + do self.dfcx_moves.each_gen_bit_frozen(id) |index| { let move = &self.move_data.moves[index]; let moved_path = move.path; - if !f(move, self.move_data.path(moved_path).loan_path) { - return false; - } + f(move, self.move_data.path(moved_path).loan_path) } - return true; } pub fn each_move_of(&self, @@ -545,31 +547,33 @@ impl FlowedMoveData { let opt_loan_path_index = self.move_data.existing_move_path(loan_path); - for self.dfcx_moves.each_bit_on_entry_frozen(id) |index| { + let mut ret = true; + + do self.dfcx_moves.each_bit_on_entry_frozen(id) |index| { let move = &self.move_data.moves[index]; let moved_path = move.path; if base_indices.iter().any(|x| x == &moved_path) { // Scenario 1 or 2: `loan_path` or some base path of // `loan_path` was moved. if !f(move, self.move_data.path(moved_path).loan_path) { - return false; + ret = false; } - loop; - } - - foreach &loan_path_index in opt_loan_path_index.iter() { - for self.move_data.each_base_path(moved_path) |p| { - if p == loan_path_index { - // Scenario 3: some extension of `loan_path` - // was moved - if !f(move, self.move_data.path(moved_path).loan_path) { - return false; + } else { + foreach &loan_path_index in opt_loan_path_index.iter() { + let cont = do self.move_data.each_base_path(moved_path) |p| { + if p == loan_path_index { + // Scenario 3: some extension of `loan_path` + // was moved + f(move, self.move_data.path(moved_path).loan_path) + } else { + true } - } + }; + if !cont { ret = false; break } } } + ret } - return true; } pub fn is_assignee(&self, @@ -601,13 +605,14 @@ impl FlowedMoveData { } }; - for self.dfcx_assign.each_bit_on_entry_frozen(id) |index| { + do self.dfcx_assign.each_bit_on_entry_frozen(id) |index| { let assignment = &self.move_data.var_assignments[index]; if assignment.path == loan_path_index && !f(assignment) { - return false; + false + } else { + true } } - return true; } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 05f42509cd4..5cacbd2ec3f 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -118,12 +118,13 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) { _ => false } }; - for walk_pat(*pat) |p| { + do walk_pat(*pat) |p| { if pat_matches_nan(p) { cx.tcx.sess.span_warn(p.span, "unmatchable NaN in pattern, \ use the is_NaN method in a guard instead"); } - } + true + }; let v = ~[*pat]; match is_useful(cx, &seen, v) { @@ -873,7 +874,7 @@ pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, if !any_by_move { return; } // pointless micro-optimization foreach pat in pats.iter() { - for walk_pat(*pat) |p| { + do walk_pat(*pat) |p| { if pat_is_binding(def_map, p) { match p.node { pat_ident(_, _, sub) => { @@ -890,6 +891,7 @@ pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, } } } - } + true + }; } } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 6c291ae2241..634fa73f6aa 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -880,11 +880,12 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> { debug!("DataFlowContext::walk_pat(pat=%s, in_out=%s)", pat.repr(self.dfcx.tcx), bits_to_str(reslice(in_out))); - for ast_util::walk_pat(pat) |p| { + do ast_util::walk_pat(pat) |p| { debug!(" p.id=%? in_out=%s", p.id, bits_to_str(reslice(in_out))); self.merge_with_entry_set(p.id, in_out); self.dfcx.apply_gen_kill(p.id, in_out); - } + true + }; } fn walk_pat_alternatives(&mut self, diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index cf028512e61..ae4bf596eb4 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -314,20 +314,22 @@ mod test { fn each_node() { let graph = create_graph(); let expected = ["A", "B", "C", "D", "E", "F"]; - for graph.each_node |idx, node| { + do graph.each_node |idx, node| { assert_eq!(&expected[*idx], graph.node_data(idx)); assert_eq!(expected[*idx], node.data); - } + true + }; } #[test] fn each_edge() { let graph = create_graph(); let expected = ["AB", "BC", "BD", "DE", "EC", "FB"]; - for graph.each_edge |idx, edge| { + do graph.each_edge |idx, edge| { assert_eq!(&expected[*idx], graph.edge_data(idx)); assert_eq!(expected[*idx], edge.data); - } + true + }; } fn test_adjacent_edges<N:Eq,E:Eq>(graph: &Graph<N,E>, @@ -338,7 +340,7 @@ mod test { assert_eq!(graph.node_data(start_index), &start_data); let mut counter = 0; - for graph.each_incoming_edge(start_index) |edge_index, edge| { + do graph.each_incoming_edge(start_index) |edge_index, edge| { assert_eq!(graph.edge_data(edge_index), &edge.data); assert!(counter < expected_incoming.len()); debug!("counter=%? expected=%? edge_index=%? edge=%?", @@ -351,11 +353,12 @@ mod test { } } counter += 1; - } + true + }; assert_eq!(counter, expected_incoming.len()); let mut counter = 0; - for graph.each_outgoing_edge(start_index) |edge_index, edge| { + do graph.each_outgoing_edge(start_index) |edge_index, edge| { assert_eq!(graph.edge_data(edge_index), &edge.data); assert!(counter < expected_outgoing.len()); debug!("counter=%? expected=%? edge_index=%? edge=%?", @@ -368,7 +371,8 @@ mod test { } } counter += 1; - } + true + }; assert_eq!(counter, expected_outgoing.len()); } diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index c389ae6eba2..c604c3835bf 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -338,11 +338,12 @@ pub fn check_builtin_bounds(cx: Context, ty: ty::t, bounds: ty::BuiltinBounds, { let kind = ty::type_contents(cx.tcx, ty); let mut missing = ty::EmptyBuiltinBounds(); - for bounds.each |bound| { + do bounds.each |bound| { if !kind.meets_bound(cx.tcx, bound) { missing.add(bound); } - } + true + }; if !missing.is_empty() { any_missing(missing); } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index c115a64039a..e9c9bcf37de 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -428,11 +428,12 @@ impl<'self> LanguageItemCollector<'self> { pub fn collect_external_language_items(&mut self) { let crate_store = self.session.cstore; do iter_crate_data(crate_store) |crate_number, _crate_metadata| { - for each_lang_item(crate_store, crate_number) + do each_lang_item(crate_store, crate_number) |node_id, item_index| { let def_id = def_id { crate: crate_number, node: node_id }; self.collect_item(item_index, def_id); - } + true + }; } } diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 2e9c19c85f8..f867790ca13 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -76,7 +76,6 @@ pub enum lint { unused_imports, unnecessary_qualification, while_true, - deprecated_for_loop, path_statement, unrecognized_lint, non_camel_case_types, @@ -168,13 +167,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[ default: warn }), - ("deprecated_for_loop", - LintSpec { - lint: deprecated_for_loop, - desc: "recommend using `foreach` or `do` instead of `for`", - default: allow - }), - ("path_statement", LintSpec { lint: path_statement, @@ -414,35 +406,33 @@ impl Context { // of what we changed so we can roll everything back after invoking the // specified closure let mut pushed = 0u; - for each_lint(self.tcx.sess, attrs) |meta, level, lintname| { - let lint = match self.dict.find_equiv(&lintname) { - None => { - self.span_lint( - unrecognized_lint, - meta.span, - fmt!("unknown `%s` attribute: `%s`", - level_to_str(level), lintname)); - loop - } - Some(lint) => { lint.lint } - }; - - let now = self.get_level(lint); - if now == forbid && level != forbid { - self.tcx.sess.span_err(meta.span, - fmt!("%s(%s) overruled by outer forbid(%s)", - level_to_str(level), - lintname, lintname)); - loop; - } - - if now != level { - let src = self.get_source(lint); - self.lint_stack.push((lint, now, src)); - pushed += 1; - self.set_level(lint, level, Node(meta.span)); + do each_lint(self.tcx.sess, attrs) |meta, level, lintname| { + match self.dict.find_equiv(&lintname) { + None => { + self.span_lint( + unrecognized_lint, + meta.span, + fmt!("unknown `%s` attribute: `%s`", + level_to_str(level), lintname)); + } + Some(lint) => { + let lint = lint.lint; + let now = self.get_level(lint); + if now == forbid && level != forbid { + self.tcx.sess.span_err(meta.span, + fmt!("%s(%s) overruled by outer forbid(%s)", + level_to_str(level), + lintname, lintname)); + } else if now != level { + let src = self.get_source(lint); + self.lint_stack.push((lint, now, src)); + pushed += 1; + self.set_level(lint, level, Node(meta.span)); + } + } } - } + true + }; // detect doc(hidden) let mut doc_hidden = do attrs.iter().any |attr| { @@ -496,7 +486,7 @@ impl Context { } } Crate(c) => { - for self.visitors.iter().advance |visitor| { + foreach visitor in self.visitors.iter() { match *visitor { OldVisitor(_, stopping) => { oldvisit::visit_crate(c, (self, stopping)) @@ -615,24 +605,6 @@ fn lint_while_true() -> oldvisit::vt<@mut Context> { }) } -fn lint_deprecated_for_loop() -> oldvisit::vt<@mut Context> { - oldvisit::mk_vt(@oldvisit::Visitor { - visit_expr: |e, (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| { - match e.node { - ast::expr_call(_, _, ast::ForSugar) | - ast::expr_method_call(_, _, _, _, _, ast::ForSugar) => { - cx.span_lint(deprecated_for_loop, e.span, - "`for` is deprecated; use `foreach <pat> in \ - <iterator>` or `do`") - } - _ => {} - } - oldvisit::visit_expr(e, (cx, vt)); - }, - .. *oldvisit::default_visitor() - }) -} - fn lint_type_limits() -> oldvisit::vt<@mut Context> { fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T, min: T, max: T) -> bool { @@ -1165,7 +1137,7 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::Crate) { }; // Install defaults. - for cx.dict.each_value |spec| { + foreach (_, spec) in cx.dict.iter() { cx.set_level(spec.lint, spec.default, Default); } @@ -1176,7 +1148,6 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::Crate) { // Register each of the lint passes with the context cx.add_oldvisit_lint(lint_while_true()); - cx.add_oldvisit_lint(lint_deprecated_for_loop()); cx.add_oldvisit_lint(lint_path_statement()); cx.add_oldvisit_lint(lint_heap()); cx.add_oldvisit_lint(lint_type_limits()); diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 5b02a826d1c..06588f22855 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -654,16 +654,21 @@ impl VisitContext { moves_map: MovesMap, arms: &[arm]) -> Option<@pat> { + let mut ret = None; foreach arm in arms.iter() { foreach &pat in arm.pats.iter() { - for ast_util::walk_pat(pat) |p| { + let cont = do ast_util::walk_pat(pat) |p| { if moves_map.contains(&p.id) { - return Some(p); + ret = Some(p); + false + } else { + true } - } + }; + if !cont { return ret } } } - return None; + ret } pub fn compute_captures(&self, fn_expr_id: NodeId) -> @[CaptureVar] { diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 6991c38799d..9bf14697d9a 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -72,14 +72,15 @@ pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @pat) -> bool { pub fn pat_bindings(dm: resolve::DefMap, pat: @pat, it: &fn(binding_mode, NodeId, span, &Path)) { - for walk_pat(pat) |p| { + do walk_pat(pat) |p| { match p.node { pat_ident(binding_mode, ref pth, _) if pat_is_binding(dm, p) => { it(binding_mode, p.id, p.span, pth); } _ => {} } - } + true + }; } pub fn pat_binding_ids(dm: resolve::DefMap, pat: @pat) -> ~[NodeId] { diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index e012d9a2ff9..761a34b72e5 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -15,8 +15,6 @@ // makes all other generics or inline functions that it references // reachable as well. -use std::iterator::IteratorUtil; - use middle::ty; use middle::typeck; @@ -392,8 +390,7 @@ impl ReachableContext { // this properly would result in the necessity of computing *type* // reachability, which might result in a compile time loss. fn mark_destructors_reachable(&self) { - for self.tcx.destructor_for_type.iter().advance - |(_, destructor_def_id)| { + foreach (_, destructor_def_id) in self.tcx.destructor_for_type.iter() { if destructor_def_id.crate == LOCAL_CRATE { self.reachable_symbols.insert(destructor_def_id.node); } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index b564dfde3c4..5a70f251aca 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1726,7 +1726,7 @@ impl Resolver { let mut modules = HashMap::new(); // Create all the items reachable by paths. - for each_path(self.session.cstore, root.def_id.get().crate) + do each_path(self.session.cstore, root.def_id.get().crate) |path_string, def_like, visibility| { debug!("(building reduced graph for external crate) found path \ @@ -1893,7 +1893,8 @@ impl Resolver { ignoring field"); } } - } + true + }; } /// Creates and adds an import directive to the given module. @@ -1992,7 +1993,7 @@ impl Resolver { self.module_to_str(module_)); self.resolve_imports_for_module(module_); - for module_.children.each_value |&child_node| { + foreach (_, &child_node) in module_.children.iter() { match child_node.get_module_if_available() { None => { // Nothing to do. @@ -2003,7 +2004,7 @@ impl Resolver { } } - for module_.anonymous_children.each_value |&child_module| { + foreach (_, &child_module) in module_.anonymous_children.iter() { self.resolve_imports_for_module_subtree(child_module); } } @@ -2446,8 +2447,7 @@ impl Resolver { assert_eq!(containing_module.glob_count, 0); // Add all resolved imports from the containing module. - for containing_module.import_resolutions.iter().advance - |(ident, target_import_resolution)| { + foreach (ident, target_import_resolution) in containing_module.import_resolutions.iter() { debug!("(resolving glob import) writing module resolution \ %? into `%s`", @@ -2536,8 +2536,7 @@ impl Resolver { } // Add external module children from the containing module. - for containing_module.external_module_children.iter().advance - |(&ident, module)| { + foreach (&ident, module) in containing_module.external_module_children.iter() { let name_bindings = @mut Resolver::create_name_bindings_from_module(*module); merge_import_resolution(ident, name_bindings); @@ -3109,7 +3108,7 @@ impl Resolver { } // Descend into children and anonymous children. - for module_.children.each_value |&child_node| { + foreach (_, &child_node) in module_.children.iter() { match child_node.get_module_if_available() { None => { // Continue. @@ -3120,7 +3119,7 @@ impl Resolver { } } - for module_.anonymous_children.each_value |&module_| { + foreach (_, &module_) in module_.anonymous_children.iter() { self.report_unresolved_imports(module_); } } @@ -3168,7 +3167,7 @@ impl Resolver { self.record_exports_for_module(module_); - for module_.children.each_value |&child_name_bindings| { + foreach (_, &child_name_bindings) in module_.children.iter() { match child_name_bindings.get_module_if_available() { None => { // Nothing to do. @@ -3179,7 +3178,7 @@ impl Resolver { } } - for module_.anonymous_children.each_value |&child_module| { + foreach (_, &child_module) in module_.anonymous_children.iter() { self.record_exports_for_module_subtree(child_module); } } @@ -3229,8 +3228,7 @@ impl Resolver { pub fn add_exports_for_module(@mut self, exports2: &mut ~[Export2], module_: @mut Module) { - for module_.import_resolutions.iter().advance |(ident, - importresolution)| { + foreach (ident, importresolution) in module_.import_resolutions.iter() { if importresolution.privacy != Public { debug!("(computing exports) not reexporting private `%s`", self.session.str_of(*ident)); @@ -4195,7 +4193,7 @@ impl Resolver { bindings_list: Option<@mut HashMap<ident,NodeId>>, visitor: ResolveVisitor) { let pat_id = pattern.id; - for walk_pat(pattern) |pattern| { + do walk_pat(pattern) |pattern| { match pattern.node { pat_ident(binding_mode, ref path, _) if !path.global && path.idents.len() == 1 => { @@ -4425,7 +4423,8 @@ impl Resolver { // Nothing to do. } } - } + true + }; } pub fn resolve_bare_identifier_pattern(@mut self, name: ident) @@ -4838,7 +4837,7 @@ impl Resolver { let mut j = this.value_ribs.len(); while j != 0 { j -= 1; - for this.value_ribs[j].bindings.each_key |&k| { + foreach (&k, _) in this.value_ribs[j].bindings.iter() { maybes.push(this.session.str_of(k)); values.push(uint::max_value); } @@ -5166,7 +5165,7 @@ impl Resolver { } // Look for trait children. - for search_module.children.each_value |&child_name_bindings| { + foreach (_, &child_name_bindings) in search_module.children.iter() { match child_name_bindings.def_for_namespace(TypeNS) { Some(def) => { match def { @@ -5189,9 +5188,7 @@ impl Resolver { } // Look for imports. - for search_module.import_resolutions.each_value - |&import_resolution| { - + foreach (_, &import_resolution) in search_module.import_resolutions.iter() { match import_resolution.target_for_namespace(TypeNS) { None => { // Continue. @@ -5370,7 +5367,7 @@ impl Resolver { debug!("Dump of module `%s`:", self.module_to_str(module_)); debug!("Children:"); - for module_.children.each_key |&name| { + foreach (&name, _) in module_.children.iter() { debug!("* %s", self.session.str_of(name)); } diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 8a8dfbc8fb9..5f9351e4e12 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -1148,7 +1148,7 @@ fn store_non_ref_bindings(bcx: @mut Block, */ let mut bcx = bcx; - for bindings_map.each_value |&binding_info| { + foreach (_, &binding_info) in bindings_map.iter() { match binding_info.trmode { TrByValue(lldest) => { let llval = Load(bcx, binding_info.llmatch); // get a T* @@ -1182,7 +1182,7 @@ fn insert_lllocals(bcx: @mut Block, BindArgument => bcx.fcx.llargs }; - for bindings_map.each_value |&binding_info| { + foreach (_, &binding_info) in bindings_map.iter() { let llval = match binding_info.trmode { // By value bindings: use the stack slot that we // copied/moved the value into @@ -1250,7 +1250,7 @@ pub fn compile_guard(bcx: @mut Block, fn drop_bindings(bcx: @mut Block, data: &ArmData) -> @mut Block { let mut bcx = bcx; - for data.bindings_map.each_value |&binding_info| { + foreach (_, &binding_info) in data.bindings_map.iter() { match binding_info.trmode { TrByValue(llval) => { bcx = glue::drop_ty(bcx, llval, binding_info.ty); diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index a9d31b15121..e0a7cd8cc0b 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2801,7 +2801,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> ValueRef { // like the multiple borrows. At least, it doesn't // like them on the current snapshot. (2013-06-14) let mut keys = ~[]; - for ccx.module_data.each_key |k| { + foreach (k, _) in ccx.module_data.iter() { keys.push(k.to_managed()); } diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index b9c20893c8e..bbf07e36975 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -736,7 +736,7 @@ pub fn emit_tydescs(ccx: &mut CrateContext) { ccx.finished_tydescs = true; let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to(); let tyds = &mut ccx.tydescs; - for tyds.each_value |&val| { + foreach (_, &val) in tyds.iter() { let ti = val; // Each of the glue functions needs to be cast to a generic type diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 2f6dff62866..bfab8e26132 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2277,7 +2277,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { // This is like with typarams below, but less "pessimistic" and also // dependent on the trait store. let mut bt = TC_NONE; - for (AllBuiltinBounds() - bounds).each |bound| { + do (AllBuiltinBounds() - bounds).each |bound| { bt = bt + match bound { BoundStatic if bounds.contains_elem(BoundSend) => TC_NONE, // Send bound implies static bound. @@ -2286,7 +2286,8 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { BoundFreeze => TC_MUTABLE, BoundSized => TC_NONE, // don't care if interior is sized }; - } + true + }; st + mt + bt } @@ -2297,7 +2298,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { let _i = indenter(); let mut tc = TC_ALL; - for type_param_def.bounds.builtin_bounds.each |bound| { + do type_param_def.bounds.builtin_bounds.each |bound| { debug!("tc = %s, bound = %?", tc.to_str(), bound); tc = tc - match bound { BoundStatic => TypeContents::nonstatic(cx), @@ -2306,7 +2307,8 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { // The dynamic-size bit can be removed at pointer-level, etc. BoundSized => TypeContents::dynamically_sized(cx), }; - } + true + }; debug!("result = %s", tc.to_str()); return tc; @@ -4424,10 +4426,11 @@ pub fn count_traits_and_supertraits(tcx: ctxt, type_param_defs: &[TypeParameterDef]) -> uint { let mut total = 0; foreach type_param_def in type_param_defs.iter() { - for each_bound_trait_and_supertraits( + do each_bound_trait_and_supertraits( tcx, type_param_def.bounds.trait_bounds) |_| { total += 1; - } + true + }; } return total; } diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index ed0503763e8..2d7840423c5 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -420,44 +420,42 @@ impl<'self> LookupContext<'self> { let tcx = self.tcx(); let mut next_bound_idx = 0; // count only trait bounds - for ty::each_bound_trait_and_supertraits(tcx, bounds) - |bound_trait_ref| - { + do ty::each_bound_trait_and_supertraits(tcx, bounds) |bound_trait_ref| { let this_bound_idx = next_bound_idx; next_bound_idx += 1; let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id); - let pos = { - match trait_methods.iter().position(|m| { - m.explicit_self != ast::sty_static && - m.ident == self.m_name }) - { - Some(pos) => pos, - None => { - debug!("trait doesn't contain method: %?", - bound_trait_ref.def_id); - loop; // check next trait or bound - } + match trait_methods.iter().position(|m| { + m.explicit_self != ast::sty_static && + m.ident == self.m_name }) + { + Some(pos) => { + let method = trait_methods[pos]; + + let cand = Candidate { + rcvr_ty: self_ty, + rcvr_substs: bound_trait_ref.substs.clone(), + method_ty: method, + origin: method_param( + method_param { + trait_id: bound_trait_ref.def_id, + method_num: pos, + param_num: param, + bound_num: this_bound_idx, + }) + }; + + debug!("pushing inherent candidate for param: %?", cand); + self.inherent_candidates.push(cand); } - }; - let method = trait_methods[pos]; - - let cand = Candidate { - rcvr_ty: self_ty, - rcvr_substs: bound_trait_ref.substs.clone(), - method_ty: method, - origin: method_param( - method_param { - trait_id: bound_trait_ref.def_id, - method_num: pos, - param_num: param, - bound_num: this_bound_idx, - }) - }; - - debug!("pushing inherent candidate for param: %?", cand); - self.inherent_candidates.push(cand); - } + None => { + debug!("trait doesn't contain method: %?", + bound_trait_ref.def_id); + // check next trait or bound + } + } + true + }; } diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index ec2e3674a43..0e50021c82c 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -131,7 +131,7 @@ fn lookup_vtables_for_param(vcx: &VtableContext, // ty is the value supplied for the type parameter A... let mut param_result = ~[]; - for ty::each_bound_trait_and_supertraits( + do ty::each_bound_trait_and_supertraits( tcx, type_param_bounds.trait_bounds) |trait_ref| { // ...and here trait_ref is each bound that was declared on A, @@ -158,7 +158,8 @@ fn lookup_vtables_for_param(vcx: &VtableContext, vcx.infcx.ty_to_str(ty))); } } - } + true + }; debug!("lookup_vtables_for_param result(\ location_info=%?, \ @@ -286,7 +287,8 @@ fn lookup_vtable_from_bounds(vcx: &VtableContext, let tcx = vcx.tcx(); let mut n_bound = 0; - for ty::each_bound_trait_and_supertraits(tcx, bounds) |bound_trait_ref| { + let mut ret = None; + do ty::each_bound_trait_and_supertraits(tcx, bounds) |bound_trait_ref| { debug!("checking bounds trait %s", bound_trait_ref.repr(vcx.tcx())); @@ -298,13 +300,14 @@ fn lookup_vtable_from_bounds(vcx: &VtableContext, let vtable = vtable_param(param, n_bound); debug!("found param vtable: %?", vtable); - return Some(vtable); + ret = Some(vtable); + false + } else { + n_bound += 1; + true } - - n_bound += 1; - } - - return None; + }; + ret } fn search_for_vtable(vcx: &VtableContext, @@ -552,7 +555,7 @@ pub fn early_resolve_expr(ex: @ast::expr, let cx = fcx.ccx; match ex.node { ast::expr_path(*) => { - for fcx.opt_node_ty_substs(ex.id) |substs| { + do fcx.opt_node_ty_substs(ex.id) |substs| { debug!("vtable resolution on parameter bounds for expr %s", ex.repr(fcx.tcx())); let def = cx.tcx.def_map.get_copy(&ex.id); @@ -571,7 +574,8 @@ pub fn early_resolve_expr(ex: @ast::expr, insert_vtables(fcx, ex.id, vtbls); } } - } + true + }; } ast::expr_paren(e) => { diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index b0d0bb3f082..b30eb67916d 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -178,17 +178,19 @@ fn resolve_type_vars_for_node(wbcx: @mut WbCtxt, sp: span, id: ast::NodeId) debug!("resolve_type_vars_for_node(id=%d, n_ty=%s, t=%s)", id, ppaux::ty_to_str(tcx, n_ty), ppaux::ty_to_str(tcx, t)); write_ty_to_tcx(tcx, id, t); - for fcx.opt_node_ty_substs(id) |substs| { + let mut ret = Some(t); + do fcx.opt_node_ty_substs(id) |substs| { let mut new_tps = ~[]; foreach subst in substs.tps.iter() { match resolve_type_vars_in_type(fcx, sp, *subst) { Some(t) => new_tps.push(t), - None => { wbcx.success = false; return None; } + None => { wbcx.success = false; ret = None; break } } } write_substs_to_tcx(tcx, id, new_tps); - } - return Some(t); + ret.is_some() + }; + ret } } } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 0fc5a3f2006..4af54cef716 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -371,9 +371,10 @@ impl CoherenceChecker { } pub fn check_implementation_coherence(&self) { - for self.crate_context.tcx.trait_impls.each_key |&trait_id| { + do self.crate_context.tcx.trait_impls.each_key |&trait_id| { self.check_implementation_coherence_of(trait_id); - } + true + }; } pub fn check_implementation_coherence_of(&self, trait_def_id: def_id) { @@ -738,14 +739,15 @@ impl CoherenceChecker { let crate_store = self.crate_context.tcx.sess.cstore; do iter_crate_data(crate_store) |crate_number, _crate_metadata| { - for each_path(crate_store, crate_number) |_, def_like, _| { + do each_path(crate_store, crate_number) |_, def_like, _| { match def_like { dl_impl(def_id) => { self.add_external_impl(&mut impls_seen, def_id) } - dl_def(_) | dl_field => loop, // Skip this. + dl_def(_) | dl_field => (), // Skip this. } - } + true + }; } } diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index 84a2215fbfe..9a4a8ca11dc 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -267,16 +267,23 @@ impl Combine for Glb { a_isr: isr_alist, r: ty::Region) -> ty::Region { - for list::each(a_isr) |pair| { + let mut ret = None; + do list::each(a_isr) |pair| { let (a_br, a_r) = *pair; if a_r == r { - return ty::re_bound(a_br); + ret = Some(ty::re_bound(a_br)); + false + } else { + true } - } + }; - this.infcx.tcx.sess.span_bug( - this.trace.origin.span(), - fmt!("could not find original bound region for %?", r)); + match ret { + Some(x) => x, + None => this.infcx.tcx.sess.span_bug( + this.trace.origin.span(), + fmt!("could not find original bound region for %?", r)) + } } fn fresh_bound_variable(this: &Glb) -> ty::Region { diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index b95d977bd43..0ed30bb61b9 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -526,7 +526,7 @@ pub fn lattice_var_and_t<L:LatticeDir + Combine, pub fn var_ids<T:Combine>(this: &T, isr: isr_alist) -> ~[RegionVid] { let mut result = ~[]; - for list::each(isr) |pair| { + do list::each(isr) |pair| { match pair.second() { ty::re_infer(ty::ReVar(r)) => { result.push(r); } r => { @@ -535,8 +535,9 @@ pub fn var_ids<T:Combine>(this: &T, isr: isr_alist) -> ~[RegionVid] { fmt!("Found non-region-vid: %?", r)); } } - } - return result; + true + }; + result } pub fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool { diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index 96d18976358..8afb5a18d4f 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -182,20 +182,27 @@ impl Combine for Lub { // in both A and B. Replace the variable with the "first" // bound region from A that we find it to be associated // with. - for list::each(a_isr) |pair| { + let mut ret = None; + do list::each(a_isr) |pair| { let (a_br, a_r) = *pair; if tainted.iter().any(|x| x == &a_r) { debug!("generalize_region(r0=%?): \ replacing with %?, tainted=%?", r0, a_br, tainted); - return ty::re_bound(a_br); + ret = Some(ty::re_bound(a_br)); + false + } else { + true } + }; + + match ret { + Some(x) => x, + None => this.infcx.tcx.sess.span_bug( + this.trace.origin.span(), + fmt!("Region %? is not associated with \ + any bound region from A!", r0)) } - - this.infcx.tcx.sess.span_bug( - this.trace.origin.span(), - fmt!("Region %? is not associated with \ - any bound region from A!", r0)); } } diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index 92f053cad89..07fd66640b5 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -1209,7 +1209,7 @@ impl RegionVarBindings { debug!("process_edges(source_vid=%?, dir=%?)", source_vid, dir); let source_node_index = NodeIndex(source_vid.to_uint()); - for graph.each_adjacent_edge(source_node_index, dir) |_, edge| { + do graph.each_adjacent_edge(source_node_index, dir) |_, edge| { match edge.data { ConstrainVarSubVar(from_vid, to_vid) => { let opp_vid = @@ -1229,7 +1229,8 @@ impl RegionVarBindings { ConstrainRegSubReg(*) => {} } - } + true + }; } } diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs index cb8f7ddb222..975dbfb07e0 100644 --- a/src/librustc/middle/typeck/infer/sub.rs +++ b/src/librustc/middle/typeck/infer/sub.rs @@ -191,7 +191,9 @@ impl Combine for Sub { // that the skolemized regions do not "leak". let new_vars = self.infcx.region_vars.vars_created_since_snapshot(snapshot); - for list::each(skol_isr) |pair| { + + let mut ret = Ok(sig); + do list::each(skol_isr) |pair| { let (skol_br, skol) = *pair; let tainted = self.infcx.region_vars.tainted(snapshot, skol); foreach tainted_region in tainted.iter() { @@ -208,16 +210,19 @@ impl Combine for Sub { // A is not as polymorphic as B: if self.a_is_expected { - return Err(ty::terr_regions_insufficiently_polymorphic( + ret = Err(ty::terr_regions_insufficiently_polymorphic( skol_br, *tainted_region)); + break } else { - return Err(ty::terr_regions_overly_polymorphic( + ret = Err(ty::terr_regions_overly_polymorphic( skol_br, *tainted_region)); + break } } - } + ret.is_ok() + }; - return Ok(sig); + ret } // Traits please (FIXME: #2794): diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 85b339daa46..6128c169967 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -299,11 +299,12 @@ impl get_and_find_region for isr_alist { } pub fn find(&self, br: ty::bound_region) -> Option<ty::Region> { - for list::each(*self) |isr| { + let mut ret = None; + do list::each(*self) |isr| { let (isr_br, isr_r) = *isr; - if isr_br == br { return Some(isr_r); } - } - return None; + if isr_br == br { ret = Some(isr_r); false } else { true } + }; + ret } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 595748390eb..beb762c7489 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -589,14 +589,15 @@ impl Repr for ty::RegionSubsts { impl Repr for ty::ParamBounds { fn repr(&self, tcx: ctxt) -> ~str { let mut res = ~[]; - for self.builtin_bounds.each |b| { + do self.builtin_bounds.each |b| { res.push(match b { ty::BoundStatic => ~"'static", ty::BoundSend => ~"Send", ty::BoundFreeze => ~"Freeze", ty::BoundSized => ~"Sized", }); - } + true + }; foreach t in self.trait_bounds.iter() { res.push(t.repr(tcx)); } @@ -832,9 +833,10 @@ impl UserString for ty::BuiltinBounds { fn user_string(&self, tcx: ctxt) -> ~str { if self.is_empty() { ~"<no-bounds>" } else { let mut result = ~[]; - for self.each |bb| { + do self.each |bb| { result.push(bb.user_string(tcx)); - } + true + }; result.connect("+") } } diff --git a/src/librusti/program.rs b/src/librusti/program.rs index 40390d67a0d..316dd09ef0a 100644 --- a/src/librusti/program.rs +++ b/src/librusti/program.rs @@ -202,13 +202,13 @@ impl Program { use extra::serialize::*; %s // view items ", self.externs, self.view_items); - for self.structs.each_value |s| { + foreach (_, s) in self.structs.iter() { // The structs aren't really useful unless they're encodable code.push_str("#[deriving(Encodable, Decodable)]"); code.push_str(*s); code.push_str("\n"); } - for self.items.each_value |s| { + foreach (_, s) in self.items.iter() { code.push_str(*s); code.push_str("\n"); } diff --git a/src/librustpkg/package_source.rs b/src/librustpkg/package_source.rs index 07e8de35fd6..7c12645b2b2 100644 --- a/src/librustpkg/package_source.rs +++ b/src/librustpkg/package_source.rs @@ -165,7 +165,7 @@ impl PkgSrc { debug!("Called check_dir, I'm in %s", dir.to_str()); let prefix = dir.components.len(); debug!("Matching against %?", self.id.local_path.filestem()); - for os::walk_dir(&dir) |pth| { + do os::walk_dir(&dir) |pth| { match pth.filename() { Some(~"lib.rs") => PkgSrc::push_crate(&mut self.libs, prefix, @@ -181,7 +181,8 @@ impl PkgSrc { pth), _ => () } - } + true + }; if self.libs.is_empty() && self.mains.is_empty() && self.tests.is_empty() && self.benchs.is_empty() { diff --git a/src/librustpkg/rustpkg.rs b/src/librustpkg/rustpkg.rs index 29c0380948f..c86d10bc3e7 100644 --- a/src/librustpkg/rustpkg.rs +++ b/src/librustpkg/rustpkg.rs @@ -206,11 +206,12 @@ impl CtxMethods for Ctx { // The package id is presumed to be the first command-line // argument let pkgid = PkgId::new(args[0].clone(), &os::getcwd()); - for each_pkg_parent_workspace(&pkgid) |workspace| { + do each_pkg_parent_workspace(&pkgid) |workspace| { debug!("found pkg %s in workspace %s, trying to build", pkgid.to_str(), workspace.to_str()); self.build(workspace, &pkgid); - } + true + }; } } "clean" => { @@ -264,17 +265,19 @@ impl CtxMethods for Ctx { self.install(&rp[0], &pkgid); } else { - for each_pkg_parent_workspace(&pkgid) |workspace| { + do each_pkg_parent_workspace(&pkgid) |workspace| { self.install(workspace, &pkgid); - } + true + }; } } } "list" => { io::println("Installed packages:"); - for installed_packages::list_installed_packages |pkg_id| { - io::println(pkg_id.local_path.to_str()); - } + do installed_packages::list_installed_packages |pkg_id| { + println(pkg_id.local_path.to_str()); + true + }; } "prefer" => { if args.len() < 1 { @@ -299,11 +302,12 @@ impl CtxMethods for Ctx { else { let rp = rust_path(); assert!(!rp.is_empty()); - for each_pkg_parent_workspace(&pkgid) |workspace| { + do each_pkg_parent_workspace(&pkgid) |workspace| { path_util::uninstall_package_from(workspace, &pkgid); note(fmt!("Uninstalled package %s (was installed in %s)", pkgid.to_str(), workspace.to_str())); - } + true + }; } } "unprefer" => { diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 570a9091d18..2010e1d4b79 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -323,7 +323,7 @@ pub fn find_and_install_dependencies(ctxt: &Ctx, debug!("In find_and_install_dependencies..."); let my_workspace = (*workspace).clone(); let my_ctxt = *ctxt; - for c.each_view_item() |vi: &ast::view_item| { + do c.each_view_item() |vi: &ast::view_item| { debug!("A view item!"); match vi.node { // ignore metadata, I guess @@ -354,7 +354,8 @@ pub fn find_and_install_dependencies(ctxt: &Ctx, // Ignore `use`s _ => () } - } + true + }; } #[cfg(windows)] diff --git a/src/libstd/char.rs b/src/libstd/char.rs index 47473c2faba..85053855432 100644 --- a/src/libstd/char.rs +++ b/src/libstd/char.rs @@ -211,12 +211,13 @@ pub fn escape_unicode(c: char, f: &fn(char)) { (c <= '\uffff') { f('u'); 4 } _ { f('U'); 8 } ); - for int::range_step(4 * (pad - 1), -1, -4) |offset| { + do int::range_step(4 * (pad - 1), -1, -4) |offset| { match ((c as u32) >> offset) & 0xf { i @ 0 .. 9 => { f('0' + i as char); } i => { f('a' + (i - 10) as char); } } - } + true + }; } /// diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs index 7991e1cb56e..abb04e637ca 100644 --- a/src/libstd/cmp.rs +++ b/src/libstd/cmp.rs @@ -236,7 +236,9 @@ mod test { fn t(o1: Ordering, o2: Ordering, e: Ordering) { assert_eq!(lexical_ordering(o1, o2), e); } - for [Less, Equal, Greater].each |&o| { + + let xs = [Less, Equal, Greater]; + foreach &o in xs.iter() { t(Less, o, Less); t(Equal, o, o); t(Greater, o, Greater); diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 9aa79090425..9842a570d7e 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -889,27 +889,34 @@ mod tests { fn test_ranges() { let mut l = ~[]; - for range_rev(14,11) |i| { + do range_rev(14,11) |i| { l.push(i); - } - for range_step(20,26,2) |i| { + true + }; + do range_step(20,26,2) |i| { l.push(i); - } - for range_step(36,30,-2) |i| { + true + }; + do range_step(36,30,-2) |i| { l.push(i); - } - for range_step(max_value - 2, max_value, 2) |i| { + true + }; + do range_step(max_value - 2, max_value, 2) |i| { l.push(i); - } - for range_step(max_value - 3, max_value, 2) |i| { + true + }; + do range_step(max_value - 3, max_value, 2) |i| { l.push(i); - } - for range_step(min_value + 2, min_value, -2) |i| { + true + }; + do range_step(min_value + 2, min_value, -2) |i| { l.push(i); - } - for range_step(min_value + 3, min_value, -2) |i| { + true + }; + do range_step(min_value + 3, min_value, -2) |i| { l.push(i); - } + true + }; assert_eq!(l, ~[13,12,11, 20,22,24, 36,34,32, @@ -919,22 +926,22 @@ mod tests { min_value+3,min_value+1]); // None of the `fail`s should execute. - for range_rev(0,10) |_i| { + do range_rev(0,10) |_i| { fail!(~"unreachable"); - } - for range_step(10,0,1) |_i| { + }; + do range_step(10,0,1) |_i| { fail!(~"unreachable"); - } - for range_step(0,10,-1) |_i| { + }; + do range_step(0,10,-1) |_i| { fail!(~"unreachable"); - } + }; } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_range_step_zero_step() { - for range_step(0,10,0) |_i| {} + do range_step(0,10,0) |_i| { true }; } } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index aa01b871b9d..a2874c96703 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -654,27 +654,34 @@ mod tests { pub fn test_ranges() { let mut l = ~[]; - for range_rev(14,11) |i| { + do range_rev(14,11) |i| { l.push(i); - } - for range_step(20,26,2) |i| { + true + }; + do range_step(20,26,2) |i| { l.push(i); - } - for range_step(36,30,-2) |i| { + true + }; + do range_step(36,30,-2) |i| { l.push(i); - } - for range_step(max_value - 2, max_value, 2) |i| { + true + }; + do range_step(max_value - 2, max_value, 2) |i| { l.push(i); - } - for range_step(max_value - 3, max_value, 2) |i| { + true + }; + do range_step(max_value - 3, max_value, 2) |i| { l.push(i); - } - for range_step(min_value + 2, min_value, -2) |i| { + true + }; + do range_step(min_value + 2, min_value, -2) |i| { l.push(i); - } - for range_step(min_value + 3, min_value, -2) |i| { + true + }; + do range_step(min_value + 3, min_value, -2) |i| { l.push(i); - } + true + }; assert_eq!(l, ~[13,12,11, 20,22,24, @@ -685,28 +692,28 @@ mod tests { min_value+3,min_value+1]); // None of the `fail`s should execute. - for range_rev(0,0) |_i| { + do range_rev(0,0) |_i| { fail!("unreachable"); - } - for range_step(10,0,1) |_i| { + }; + do range_step(10,0,1) |_i| { fail!("unreachable"); - } - for range_step(0,1,-10) |_i| { + }; + do range_step(0,1,-10) |_i| { fail!("unreachable"); - } + }; } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_range_step_zero_step_up() { - for range_step(0,10,0) |_i| {} + do range_step(0,10,0) |_i| { true }; } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_range_step_zero_step_down() { - for range_step(0,-10,0) |_i| {} + do range_step(0,-10,0) |_i| { true }; } } diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs index 20686e7a251..69e1852e662 100644 --- a/src/libstd/rand.rs +++ b/src/libstd/rand.rs @@ -701,7 +701,7 @@ impl IsaacRng { if use_rsl { macro_rules! memloop ( ($arr:expr) => {{ - for u32::range_step(0, RAND_SIZE, 8) |i| { + do u32::range_step(0, RAND_SIZE, 8) |i| { a+=$arr[i ]; b+=$arr[i+1]; c+=$arr[i+2]; d+=$arr[i+3]; e+=$arr[i+4]; f+=$arr[i+5]; @@ -711,20 +711,22 @@ impl IsaacRng { self.mem[i+2]=c; self.mem[i+3]=d; self.mem[i+4]=e; self.mem[i+5]=f; self.mem[i+6]=g; self.mem[i+7]=h; - } + true + }; }} ); memloop!(self.rsl); memloop!(self.mem); } else { - for u32::range_step(0, RAND_SIZE, 8) |i| { + do u32::range_step(0, RAND_SIZE, 8) |i| { mix!(); self.mem[i ]=a; self.mem[i+1]=b; self.mem[i+2]=c; self.mem[i+3]=d; self.mem[i+4]=e; self.mem[i+5]=f; self.mem[i+6]=g; self.mem[i+7]=h; - } + true + }; } self.isaac(); @@ -764,12 +766,13 @@ impl IsaacRng { let r = [(0, MIDPOINT), (MIDPOINT, 0)]; foreach &(mr_offset, m2_offset) in r.iter() { - for uint::range_step(0, MIDPOINT, 4) |base| { + do uint::range_step(0, MIDPOINT, 4) |base| { rngstep!(0, 13); rngstep!(1, -6); rngstep!(2, 2); rngstep!(3, -16); - } + true + }; } self.a = a; diff --git a/src/libstd/run.rs b/src/libstd/run.rs index 65316d4092b..4c67d844c7e 100644 --- a/src/libstd/run.rs +++ b/src/libstd/run.rs @@ -665,9 +665,10 @@ fn spawn_process_os(prog: &str, args: &[~str], fail!("failure in dup3(err_fd, 2): %s", os::last_os_error()); } // close all other fds - for int::range_rev(getdtablesize() as int, 3) |fd| { + do int::range_rev(getdtablesize() as int, 3) |fd| { close(fd as c_int); - } + true + }; do with_dirp(dir) |dirp| { if !dirp.is_null() && chdir(dirp) == -1 { diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs index 97e2b3b3c34..9bcf430ff90 100644 --- a/src/libstd/trie.rs +++ b/src/libstd/trie.rs @@ -272,14 +272,13 @@ impl<T> TrieNode<T> { } fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool { - for uint::range_rev(self.children.len(), 0) |idx| { + do uint::range_rev(self.children.len(), 0) |idx| { match self.children[idx] { - Internal(ref x) => if !x.each_reverse(|i,t| f(i,t)) { return false }, - External(k, ref v) => if !f(&k, v) { return false }, - Nothing => () + Internal(ref x) => x.each_reverse(|i,t| f(i,t)), + External(k, ref v) => f(&k, v), + Nothing => true } } - true } fn mutate_values<'a>(&'a mut self, f: &fn(&uint, &mut T) -> bool) -> bool { @@ -417,17 +416,19 @@ mod test_map { let mut trie = TrieMap::new(); let n = 300; - for uint::range_step(1, n, 2) |x| { + do uint::range_step(1, n, 2) |x| { assert!(trie.insert(x, x + 1)); assert!(trie.contains_key(&x)); check_integrity(&trie.root); - } + true + }; - for uint::range_step(0, n, 2) |x| { + do uint::range_step(0, n, 2) |x| { assert!(!trie.contains_key(&x)); assert!(trie.insert(x, x + 1)); check_integrity(&trie.root); - } + true + }; foreach x in range(0u, n) { assert!(trie.contains_key(&x)); @@ -435,17 +436,19 @@ mod test_map { check_integrity(&trie.root); } - for uint::range_step(1, n, 2) |x| { + do uint::range_step(1, n, 2) |x| { assert!(trie.remove(&x)); assert!(!trie.contains_key(&x)); check_integrity(&trie.root); - } + true + }; - for uint::range_step(0, n, 2) |x| { + do uint::range_step(0, n, 2) |x| { assert!(trie.contains_key(&x)); assert!(!trie.insert(x, x + 1)); check_integrity(&trie.root); - } + true + }; } #[test] @@ -471,9 +474,10 @@ mod test_map { fn test_each_break() { let mut m = TrieMap::new(); - for uint::range_rev(uint::max_value, uint::max_value - 10000) |x| { + do uint::range_rev(uint::max_value, uint::max_value - 10000) |x| { m.insert(x, x / 2); - } + true + }; let mut n = uint::max_value - 10000; do m.each |k, v| { @@ -511,9 +515,10 @@ mod test_map { fn test_each_reverse_break() { let mut m = TrieMap::new(); - for uint::range_rev(uint::max_value, uint::max_value - 10000) |x| { + do uint::range_rev(uint::max_value, uint::max_value - 10000) |x| { m.insert(x, x / 2); - } + true + }; let mut n = uint::max_value - 1; do m.each_reverse |k, v| { diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index e086334eb48..dc6919efcf9 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -94,12 +94,17 @@ pub fn lookup(name: &str) -> Option<Abi> { * Returns the ABI with the given name (if any). */ - for each_abi |abi| { + let mut res = None; + + do each_abi |abi| { if name == abi.data().name { - return Some(abi); + res = Some(abi); + false + } else { + true } - } - return None; + }; + res } pub fn all_names() -> ~[&'static str] { @@ -193,21 +198,24 @@ impl AbiSet { pub fn for_arch(&self, arch: Architecture) -> Option<Abi> { // NB---Single platform ABIs come first - for self.each |abi| { + + let mut res = None; + + do self.each |abi| { let data = abi.data(); match data.abi_arch { - Archs(a) if (a & arch.bit()) != 0 => { return Some(abi); } - Archs(_) => { } - RustArch | AllArch => { return Some(abi); } + Archs(a) if (a & arch.bit()) != 0 => { res = Some(abi); false } + Archs(_) => { true } + RustArch | AllArch => { res = Some(abi); false } } - } + }; - None + res } pub fn check_valid(&self) -> Option<(Abi, Abi)> { let mut abis = ~[]; - for self.each |abi| { abis.push(abi); } + do self.each |abi| { abis.push(abi); true }; foreach (i, abi) in abis.iter().enumerate() { let data = abi.data(); @@ -261,9 +269,10 @@ impl ToStr for Abi { impl ToStr for AbiSet { fn to_str(&self) -> ~str { let mut strs = ~[]; - for self.each |abi| { + do self.each |abi| { strs.push(abi.data().name); - } + true + }; fmt!("\"%s\"", strs.connect(" ")) } } diff --git a/src/libsyntax/oldvisit.rs b/src/libsyntax/oldvisit.rs index a39dc38a856..2de4aa474e5 100644 --- a/src/libsyntax/oldvisit.rs +++ b/src/libsyntax/oldvisit.rs @@ -126,10 +126,10 @@ pub fn visit_mod<E:Clone>(m: &_mod, _sp: span, _id: NodeId, (e, v): (E, vt<E>)) { - for m.view_items.iter().advance |vi| { + foreach vi in m.view_items.iter() { (v.visit_view_item)(vi, (e.clone(), v)); } - for m.items.iter().advance |i| { + foreach i in m.items.iter() { (v.visit_item)(*i, (e.clone(), v)); } } @@ -173,10 +173,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) { } item_mod(ref m) => (v.visit_mod)(m, i.span, i.id, (e, v)), item_foreign_mod(ref nm) => { - for nm.view_items.iter().advance |vi| { + foreach vi in nm.view_items.iter() { (v.visit_view_item)(vi, (e.clone(), v)); } - for nm.items.iter().advance |ni| { + foreach ni in nm.items.iter() { (v.visit_foreign_item)(*ni, (e.clone(), v)); } } @@ -194,11 +194,11 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) { } item_impl(ref tps, ref traits, ref ty, ref methods) => { (v.visit_generics)(tps, (e.clone(), v)); - for traits.iter().advance |p| { + foreach p in traits.iter() { visit_trait_ref(p, (e.clone(), v)); } (v.visit_ty)(ty, (e.clone(), v)); - for methods.iter().advance |m| { + foreach m in methods.iter() { visit_method_helper(*m, (e.clone(), v)) } } @@ -208,10 +208,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) { } item_trait(ref generics, ref traits, ref methods) => { (v.visit_generics)(generics, (e.clone(), v)); - for traits.iter().advance |p| { + foreach p in traits.iter() { visit_path(&p.path, (e.clone(), v)); } - for methods.iter().advance |m| { + foreach m in methods.iter() { (v.visit_trait_method)(m, (e.clone(), v)); } } @@ -222,10 +222,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) { pub fn visit_enum_def<E:Clone>(enum_definition: &ast::enum_def, tps: &Generics, (e, v): (E, vt<E>)) { - for enum_definition.variants.iter().advance |vr| { + foreach vr in enum_definition.variants.iter() { match vr.node.kind { tuple_variant_kind(ref variant_args) => { - for variant_args.iter().advance |va| { + foreach va in variant_args.iter() { (v.visit_ty)(&va.ty, (e.clone(), v)); } } @@ -235,7 +235,7 @@ pub fn visit_enum_def<E:Clone>(enum_definition: &ast::enum_def, } } // Visit the disr expr if it exists - for vr.node.disr_expr.iter().advance |ex| { + foreach ex in vr.node.disr_expr.iter() { (v.visit_expr)(*ex, (e.clone(), v)) } } @@ -250,12 +250,12 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) { (v.visit_ty)(mt.ty, (e, v)); }, ty_tup(ref ts) => { - for ts.iter().advance |tt| { + foreach tt in ts.iter() { (v.visit_ty)(tt, (e.clone(), v)); } }, ty_closure(ref f) => { - for f.decl.inputs.iter().advance |a| { + foreach a in f.decl.inputs.iter() { (v.visit_ty)(&a.ty, (e.clone(), v)); } (v.visit_ty)(&f.decl.output, (e.clone(), v)); @@ -264,7 +264,7 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) { }; }, ty_bare_fn(ref f) => { - for f.decl.inputs.iter().advance |a| { + foreach a in f.decl.inputs.iter() { (v.visit_ty)(&a.ty, (e.clone(), v)); } (v.visit_ty)(&f.decl.output, (e, v)); @@ -284,27 +284,27 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) { } pub fn visit_path<E:Clone>(p: &Path, (e, v): (E, vt<E>)) { - for p.types.iter().advance |tp| { (v.visit_ty)(tp, (e.clone(), v)); } + foreach tp in p.types.iter() { (v.visit_ty)(tp, (e.clone(), v)); } } pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) { match p.node { pat_enum(ref path, ref children) => { visit_path(path, (e.clone(), v)); - for children.iter().advance |children| { - for children.iter().advance |child| { + foreach children in children.iter() { + foreach child in children.iter() { (v.visit_pat)(*child, (e.clone(), v)); } } } pat_struct(ref path, ref fields, _) => { visit_path(path, (e.clone(), v)); - for fields.iter().advance |f| { + foreach f in fields.iter() { (v.visit_pat)(f.pat, (e.clone(), v)); } } pat_tup(ref elts) => { - for elts.iter().advance |elt| { + foreach elt in elts.iter() { (v.visit_pat)(*elt, (e.clone(), v)) } }, @@ -313,7 +313,7 @@ pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) { }, pat_ident(_, ref path, ref inner) => { visit_path(path, (e.clone(), v)); - for inner.iter().advance |subpat| { + foreach subpat in inner.iter() { (v.visit_pat)(*subpat, (e.clone(), v)) } } @@ -324,13 +324,13 @@ pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) { } pat_wild => (), pat_vec(ref before, ref slice, ref after) => { - for before.iter().advance |elt| { + foreach elt in before.iter() { (v.visit_pat)(*elt, (e.clone(), v)); } - for slice.iter().advance |elt| { + foreach elt in slice.iter() { (v.visit_pat)(*elt, (e.clone(), v)); } - for after.iter().advance |tail| { + foreach tail in after.iter() { (v.visit_pat)(*tail, (e.clone(), v)); } } @@ -351,7 +351,7 @@ pub fn visit_foreign_item<E:Clone>(ni: &foreign_item, (e, v): (E, vt<E>)) { pub fn visit_ty_param_bounds<E:Clone>(bounds: &OptVec<TyParamBound>, (e, v): (E, vt<E>)) { - for bounds.iter().advance |bound| { + foreach bound in bounds.iter() { match *bound { TraitTyParamBound(ref ty) => visit_trait_ref(ty, (e.clone(), v)), RegionTyParamBound => {} @@ -360,13 +360,13 @@ pub fn visit_ty_param_bounds<E:Clone>(bounds: &OptVec<TyParamBound>, } pub fn visit_generics<E:Clone>(generics: &Generics, (e, v): (E, vt<E>)) { - for generics.ty_params.iter().advance |tp| { + foreach tp in generics.ty_params.iter() { visit_ty_param_bounds(&tp.bounds, (e.clone(), v)); } } pub fn visit_fn_decl<E:Clone>(fd: &fn_decl, (e, v): (E, vt<E>)) { - for fd.inputs.iter().advance |a| { + foreach a in fd.inputs.iter() { (v.visit_pat)(a.pat, (e.clone(), v)); (v.visit_ty)(&a.ty, (e.clone(), v)); } @@ -399,7 +399,7 @@ pub fn visit_fn<E:Clone>(fk: &fn_kind, } pub fn visit_ty_method<E:Clone>(m: &TypeMethod, (e, v): (E, vt<E>)) { - for m.decl.inputs.iter().advance |a| { + foreach a in m.decl.inputs.iter() { (v.visit_ty)(&a.ty, (e.clone(), v)); } (v.visit_generics)(&m.generics, (e.clone(), v)); @@ -420,7 +420,7 @@ pub fn visit_struct_def<E:Clone>( _id: NodeId, (e, v): (E, vt<E>) ) { - for sd.fields.iter().advance |f| { + foreach f in sd.fields.iter() { (v.visit_struct_field)(*f, (e.clone(), v)); } } @@ -430,10 +430,10 @@ pub fn visit_struct_field<E:Clone>(sf: &struct_field, (e, v): (E, vt<E>)) { } pub fn visit_block<E:Clone>(b: &Block, (e, v): (E, vt<E>)) { - for b.view_items.iter().advance |vi| { + foreach vi in b.view_items.iter() { (v.visit_view_item)(vi, (e.clone(), v)); } - for b.stmts.iter().advance |s| { + foreach s in b.stmts.iter() { (v.visit_stmt)(*s, (e.clone(), v)); } visit_expr_opt(b.expr, (e, v)); @@ -460,7 +460,7 @@ pub fn visit_expr_opt<E>(eo: Option<@expr>, (e, v): (E, vt<E>)) { } pub fn visit_exprs<E:Clone>(exprs: &[@expr], (e, v): (E, vt<E>)) { - for exprs.iter().advance |ex| { (v.visit_expr)(*ex, (e.clone(), v)); } + foreach ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); } } pub fn visit_mac<E>(_m: &mac, (_e, _v): (E, vt<E>)) { @@ -477,13 +477,13 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { } expr_struct(ref p, ref flds, base) => { visit_path(p, (e.clone(), v)); - for flds.iter().advance |f| { + foreach f in flds.iter() { (v.visit_expr)(f.expr, (e.clone(), v)); } visit_expr_opt(base, (e.clone(), v)); } expr_tup(ref elts) => { - for elts.iter().advance |el| { (v.visit_expr)(*el, (e.clone(), v)) } + foreach el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) } } expr_call(callee, ref args, _) => { visit_exprs(*args, (e.clone(), v)); @@ -491,7 +491,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { } expr_method_call(_, callee, _, ref tys, ref args, _) => { visit_exprs(*args, (e.clone(), v)); - for tys.iter().advance |tp| { + foreach tp in tys.iter() { (v.visit_ty)(tp, (e.clone(), v)); } (v.visit_expr)(callee, (e.clone(), v)); @@ -524,7 +524,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { expr_loop(ref b, _) => (v.visit_block)(b, (e.clone(), v)), expr_match(x, ref arms) => { (v.visit_expr)(x, (e.clone(), v)); - for arms.iter().advance |a| { (v.visit_arm)(a, (e.clone(), v)); } + foreach a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); } } expr_fn_block(ref decl, ref body) => { (v.visit_fn)( @@ -547,7 +547,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { } expr_field(x, _, ref tys) => { (v.visit_expr)(x, (e.clone(), v)); - for tys.iter().advance |tp| { + foreach tp in tys.iter() { (v.visit_ty)(tp, (e.clone(), v)); } } @@ -567,10 +567,10 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { expr_mac(ref mac) => visit_mac(mac, (e.clone(), v)), expr_paren(x) => (v.visit_expr)(x, (e.clone(), v)), expr_inline_asm(ref a) => { - for a.inputs.iter().advance |&(_, input)| { + foreach &(_, input) in a.inputs.iter() { (v.visit_expr)(input, (e.clone(), v)); } - for a.outputs.iter().advance |&(_, out)| { + foreach &(_, out) in a.outputs.iter() { (v.visit_expr)(out, (e.clone(), v)); } } @@ -579,7 +579,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) { } pub fn visit_arm<E:Clone>(a: &arm, (e, v): (E, vt<E>)) { - for a.pats.iter().advance |p| { (v.visit_pat)(*p, (e.clone(), v)); } + foreach p in a.pats.iter() { (v.visit_pat)(*p, (e.clone(), v)); } visit_expr_opt(a.guard, (e.clone(), v)); (v.visit_block)(&a.body, (e.clone(), v)); } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 386f027d6e1..ac3c50a53de 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -11,7 +11,7 @@ use abi; use abi::AbiSet; use ast::{Sigil, BorrowedSigil, ManagedSigil, OwnedSigil}; -use ast::{CallSugar, NoSugar, DoSugar, ForSugar}; +use ast::{CallSugar, NoSugar, DoSugar}; use ast::{TyBareFn, TyClosure}; use ast::{RegionTyParamBound, TraitTyParamBound}; use ast::{provided, public, purity}; @@ -24,7 +24,7 @@ use ast::{expr, expr_, expr_addr_of, expr_match, expr_again}; use ast::{expr_assign, expr_assign_op, expr_binary, expr_block}; use ast::{expr_break, expr_call, expr_cast, expr_do_body}; use ast::{expr_field, expr_fn_block, expr_if, expr_index}; -use ast::{expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac}; +use ast::{expr_lit, expr_log, expr_loop, expr_mac}; use ast::{expr_method_call, expr_paren, expr_path, expr_repeat}; use ast::{expr_ret, expr_self, expr_struct, expr_tup, expr_unary}; use ast::{expr_vec, expr_vstore, expr_vstore_mut_box}; @@ -1626,8 +1626,7 @@ impl Parser { } else if self.eat_keyword(keywords::ForEach) { return self.parse_for_expr(); } else if self.eat_keyword(keywords::For) { - return self.parse_sugary_call_expr(lo, ~"for", ForSugar, - expr_loop_body); + return self.parse_for_expr(); } else if self.eat_keyword(keywords::Do) { return self.parse_sugary_call_expr(lo, ~"do", DoSugar, expr_do_body); @@ -2326,9 +2325,9 @@ impl Parser { } } - // parse a 'foreach' .. 'in' expression ('foreach' token already eaten) + // parse a 'for' .. 'in' expression ('for' token already eaten) pub fn parse_for_expr(&self) -> @expr { - // Parse: `foreach <src_pat> in <src_expr> <src_loop_block>` + // Parse: `for <src_pat> in <src_expr> <src_loop_block>` let lo = self.last_span.lo; let pat = self.parse_pat(); diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 922a518a382..10d9c1a6b9b 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -53,21 +53,24 @@ fn descending<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint) { io::println(" Descending integers:"); do timed("insert") { - for uint::range_rev(n_keys, 0) |i| { + do uint::range_rev(n_keys, 0) |i| { map.insert(i, i + 1); - } + true + }; } do timed("search") { - for uint::range_rev(n_keys, 0) |i| { + do uint::range_rev(n_keys, 0) |i| { assert_eq!(map.find(&i).unwrap(), &(i + 1)); - } + true + }; } do timed("remove") { - for uint::range_rev(n_keys, 0) |i| { + do uint::range_rev(n_keys, 0) |i| { assert!(map.remove(&i)); - } + true + }; } } diff --git a/src/test/compile-fail/bad-for-loop-2.rs b/src/test/compile-fail/bad-for-loop-2.rs deleted file mode 100644 index 4f90ff5802d..00000000000 --- a/src/test/compile-fail/bad-for-loop-2.rs +++ /dev/null @@ -1,15 +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. - -fn main() { - fn quux(_: &fn(&int) -> bool) -> () { } - for quux |_| { } //~ ERROR expected `for` closure to return - // `bool`, but found `()` -} diff --git a/src/test/compile-fail/bad-for-loop.rs b/src/test/compile-fail/bad-for-loop.rs deleted file mode 100644 index 83616b708f2..00000000000 --- a/src/test/compile-fail/bad-for-loop.rs +++ /dev/null @@ -1,16 +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. - -fn main() { - fn quux(_: &fn(&int) -> int) -> bool { true } - for quux |_| { } //~ ERROR A `for` loop iterator should expect a - // closure that returns `bool`. This iterator - // expects a closure that returns `int`. -} diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs index 642e4653cd0..869ef0591e4 100644 --- a/src/test/compile-fail/borrowck-lend-flow-loop.rs +++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs @@ -17,7 +17,6 @@ fn borrow(_v: &int) {} fn borrow_mut(_v: &mut int) {} fn cond() -> bool { fail!() } -fn for_func(_f: &fn() -> bool) -> bool { fail!() } fn produce<T>() -> T { fail!(); } fn inc(v: &mut ~int) { @@ -70,17 +69,6 @@ fn while_aliased_mut() { } } -fn for_loop_aliased_mut() { - // In this instance, the borrow is carried through the loop. - - let mut v = ~3; - let mut w = ~4; - let mut _x = &w; - for for_func { - borrow_mut(v); //~ ERROR cannot borrow - _x = &v; - } -} fn loop_aliased_mut_break() { // In this instance, the borrow is carried through the loop. @@ -110,21 +98,6 @@ fn while_aliased_mut_break() { borrow_mut(v); //~ ERROR cannot borrow } -fn for_aliased_mut_break() { - // In this instance, the borrow is carried through the loop. - - let mut v = ~3; - let mut w = ~4; - let mut _x = &w; - for for_func { - // here we cannot be sure that `for_func` respects the break below - borrow_mut(v); //~ ERROR cannot borrow - _x = &v; - break; - } - borrow_mut(v); //~ ERROR cannot borrow -} - fn while_aliased_mut_cond(cond: bool, cond2: bool) { let mut v = ~3; let mut w = ~4; diff --git a/src/test/compile-fail/issue-3651.rs b/src/test/compile-fail/issue-3651.rs deleted file mode 100644 index 7e65d8ab82d..00000000000 --- a/src/test/compile-fail/issue-3651.rs +++ /dev/null @@ -1,16 +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::task; - -fn main() { - for task::spawn { return true; } //~ ERROR A `for` loop iterator should expect a closure that - //~^ ERROR expected `for` closure to return `bool` -} diff --git a/src/test/compile-fail/lint-deprecated-for-loop.rs b/src/test/compile-fail/lint-deprecated-for-loop.rs deleted file mode 100644 index 5570562cf8b..00000000000 --- a/src/test/compile-fail/lint-deprecated-for-loop.rs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright 2013 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. - - -#[forbid(deprecated_for_loop)]; - -fn f(_: &fn() -> bool) -> bool { - true -} - -fn main() { - for f {} //~ ERROR `for` is deprecated -} diff --git a/src/test/compile-fail/regionck-closure-lifetimes.rs b/src/test/compile-fail/regionck-closure-lifetimes.rs index 604b324cbbd..c9a3e044d9c 100644 --- a/src/test/compile-fail/regionck-closure-lifetimes.rs +++ b/src/test/compile-fail/regionck-closure-lifetimes.rs @@ -31,16 +31,6 @@ fn no_env_no_for<'a>(_: &'a uint, blk: &fn(p: &'a fn())) { blk(|| ()) } -fn no_env_but_for<'a>(_: &'a uint, blk: &fn(p: &'a fn() -> bool) -> bool) { - // Test that a `for` loop is considered to hvae - // implicit free variables. - // - // FIXME(#4846): The `&'a uint` parameter is needed to ensure that `'a` - // is a free and not bound region name. - - for blk { } //~ ERROR cannot infer an appropriate lifetime -} - fn repeating_loop() { // Test that the closure cannot be created within `loop` loop and // called without, even though the state that it closes over is diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index b65b18e1ab3..5269f7dab5a 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -30,14 +30,14 @@ impl<A> iterable<A> for ~[A] { fn length<A, T: iterable<A>>(x: T) -> uint { let mut len = 0; - for x.iterate() |_y| { len += 1 } + do x.iterate() |_y| { len += 1; true }; return len; } pub fn main() { let x = ~[0,1,2,3]; // Call a method - for x.iterate() |y| { assert!(x[*y] == *y); } + do x.iterate() |y| { assert!(x[*y] == *y); true }; // Call a parameterized function assert_eq!(length(x.clone()), x.len()); // Call a parameterized function, with type arguments that require @@ -47,7 +47,7 @@ pub fn main() { // Now try it with a type that *needs* to be borrowed let z = [0,1,2,3]; // Call a method - for z.iterate() |y| { assert!(z[*y] == *y); } + do z.iterate() |y| { assert!(z[*y] == *y); true }; // Call a parameterized function assert_eq!(length::<int, &[int]>(z), z.len()); } diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs index ecd3b0aa529..20c9032fbd2 100644 --- a/src/test/run-pass/borrowck-mut-uniq.rs +++ b/src/test/run-pass/borrowck-mut-uniq.rs @@ -31,9 +31,10 @@ pub fn main() { add_int(ints, 22); add_int(ints, 44); - for iter_ints(ints) |i| { + do iter_ints(ints) |i| { error!("int = %d", *i); - } + true + }; error!("ints=%?", ints); } diff --git a/src/test/run-pass/do-for-empty-args.rs b/src/test/run-pass/do-empty-args.rs index fb1bc37fd5e..b7c97392ec1 100644 --- a/src/test/run-pass/do-for-empty-args.rs +++ b/src/test/run-pass/do-empty-args.rs @@ -9,7 +9,7 @@ // except according to those terms. // no-reformat -// Testing various forms of `do` and `for` with empty arg lists +// Testing various forms of `do` with empty arg lists fn f(f: &fn() -> bool) -> bool { true @@ -20,8 +20,4 @@ pub fn main() { do f() { true }; do f || { true }; do f { true }; - for f() || { } - for f() { } - for f || { } - for f { } } diff --git a/src/test/run-pass/do-for-no-args.rs b/src/test/run-pass/do-no-args.rs index e9d7c946a9a..2af44199322 100644 --- a/src/test/run-pass/do-for-no-args.rs +++ b/src/test/run-pass/do-no-args.rs @@ -8,13 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Testing that we can drop the || in for/do exprs +// Testing that we can drop the || in do exprs fn f(f: @fn() -> bool) -> bool { true } fn d(f: @fn()) { } pub fn main() { - for f { } do d { } } diff --git a/src/test/run-pass/num-range-rev.rs b/src/test/run-pass/num-range-rev.rs index 869888c7dbc..5eecbe7e03a 100644 --- a/src/test/run-pass/num-range-rev.rs +++ b/src/test/run-pass/num-range-rev.rs @@ -40,75 +40,87 @@ pub fn main() { // int and uint have same result for // Sum{100 > i >= 2} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99 let mut sum = 0u; - for uint_range_rev(100, 2) |i| { + do uint_range_rev(100, 2) |i| { sum += i; - } + true + }; assert_eq!(sum, 4949); let mut sum = 0i; - for int_range_rev(100, 2) |i| { + do int_range_rev(100, 2) |i| { sum += i; - } + true + }; assert_eq!(sum, 4949); // elements are visited in correct order let primes = [2,3,5,7,11]; let mut prod = 1i; - for uint_range_rev(5, 0) |i| { + do uint_range_rev(5, 0) |i| { printfln!("uint 4 downto 0: %u", i); prod *= int::pow(primes[i], i); - } + true + }; assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1); let mut prod = 1i; - for int_range_rev(5, 0) |i| { + do int_range_rev(5, 0) |i| { printfln!("int 4 downto 0: %d", i); prod *= int::pow(primes[i], i as uint); - } + true + }; assert_eq!(prod, 11*11*11*11*7*7*7*5*5*3*1); // range and range_rev are symmetric. let mut sum_up = 0u; - for uint_range(10, 30) |i| { + do uint_range(10, 30) |i| { sum_up += i; - } + true + }; let mut sum_down = 0u; - for uint_range_rev(30, 10) |i| { + do uint_range_rev(30, 10) |i| { sum_down += i; - } + true + }; assert_eq!(sum_up, sum_down); let mut sum_up = 0; - for int_range(-20, 10) |i| { + do int_range(-20, 10) |i| { sum_up += i; - } + true + }; let mut sum_down = 0; - for int_range_rev(10, -20) |i| { + do int_range_rev(10, -20) |i| { sum_down += i; - } + true + }; assert_eq!(sum_up, sum_down); // empty ranges - for int_range_rev(10, 10) |_| { + do int_range_rev(10, 10) |_| { fail!("range should be empty when start == stop"); - } + true + }; - for uint_range_rev(0, 1) |_| { + do uint_range_rev(0, 1) |_| { fail!("range should be empty when start-1 underflows"); - } + true + }; // range iterations do not wrap/underflow let mut uflo_loop_visited = ~[]; - for int_range_step(int::min_value+15, int::min_value, -4) |x| { + do int_range_step(int::min_value+15, int::min_value, -4) |x| { uflo_loop_visited.push(x - int::min_value); - } + true + }; assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]); let mut uflo_loop_visited = ~[]; - for uint_range_step(uint::min_value+15, uint::min_value, -4) |x| { + do uint_range_step(uint::min_value+15, uint::min_value, -4) |x| { uflo_loop_visited.push(x - uint::min_value); - } + true + }; assert_eq!(uflo_loop_visited, ~[15, 11, 7, 3]); } diff --git a/src/test/run-pass/num-range.rs b/src/test/run-pass/num-range.rs index 3960f489c6a..7376edef8a8 100644 --- a/src/test/run-pass/num-range.rs +++ b/src/test/run-pass/num-range.rs @@ -32,88 +32,101 @@ pub fn main() { // int and uint have same result for // Sum{2 <= i < 100} == (Sum{1 <= i <= 99} - 1) == n*(n+1)/2 - 1 for n=99 let mut sum = 0u; - for uint_range(2, 100) |i| { + do uint_range(2, 100) |i| { sum += i; - } + true + }; assert_eq!(sum, 4949); let mut sum = 0i; - for int_range(2, 100) |i| { + do int_range(2, 100) |i| { sum += i; - } + true + }; assert_eq!(sum, 4949); // elements are visited in correct order let primes = [2,3,5,7]; let mut prod = 1i; - for uint_range(0, 4) |i| { + do uint_range(0, 4) |i| { prod *= int::pow(primes[i], i); - } + true + }; assert_eq!(prod, 1*3*5*5*7*7*7); let mut prod = 1i; - for int_range(0, 4) |i| { + do int_range(0, 4) |i| { prod *= int::pow(primes[i], i as uint); - } + true + }; assert_eq!(prod, 1*3*5*5*7*7*7); // empty ranges - for int_range(10, 10) |_| { + do int_range(10, 10) |_| { fail!("range should be empty when start == stop"); - } + true + }; - for uint_range(10, 10) |_| { + do uint_range(10, 10) |_| { fail!("range should be empty when start == stop"); - } + true + }; // range iterations do not wrap/overflow let mut oflo_loop_visited = ~[]; - for uint_range_step(uint::max_value-15, uint::max_value, 4) |x| { + do uint_range_step(uint::max_value-15, uint::max_value, 4) |x| { oflo_loop_visited.push(uint::max_value - x); - } + true + }; assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]); let mut oflo_loop_visited = ~[]; - for int_range_step(int::max_value-15, int::max_value, 4) |x| { + do int_range_step(int::max_value-15, int::max_value, 4) |x| { oflo_loop_visited.push(int::max_value - x); - } + true + }; assert_eq!(oflo_loop_visited, ~[15, 11, 7, 3]); // range_step never passes nor visits the stop element - for int_range_step(0, 21, 3) |x| { + do int_range_step(0, 21, 3) |x| { assert!(x < 21); - } + true + }; // range_step_inclusive will never pass stop element, and may skip it. let mut saw21 = false; - for uint::range_step_inclusive(0, 21, 4) |x| { + do uint::range_step_inclusive(0, 21, 4) |x| { assert!(x <= 21); if x == 21 { saw21 = true; } - } + true + }; assert!(!saw21); let mut saw21 = false; - for int::range_step_inclusive(0, 21, 4) |x| { + do int::range_step_inclusive(0, 21, 4) |x| { assert!(x <= 21); if x == 21 { saw21 = true; } - } + true + }; assert!(!saw21); // range_step_inclusive will never pass stop element, but may visit it. let mut saw21 = false; - for uint::range_step_inclusive(0, 21, 3) |x| { + do uint::range_step_inclusive(0, 21, 3) |x| { assert!(x <= 21); printfln!("saw: %u", x); if x == 21 { saw21 = true; } - } + true + }; assert!(saw21); let mut saw21 = false; - for int::range_step_inclusive(0, 21, 3) |x| { + do int::range_step_inclusive(0, 21, 3) |x| { assert!(x <= 21); if x == 21 { saw21 = true; } - } + true + }; assert!(saw21); } diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs deleted file mode 100644 index 341c1b96e36..00000000000 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ /dev/null @@ -1,75 +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. - -// xfail-fast - -use std::cmp::Eq; -use std::vec; - -fn iter<T>(v: ~[T], it: &fn(&T) -> bool) -> bool { - let mut i = 0u; - let mut l = v.len(); - while i < l { - if !it(&v[i]) { return false; } - i += 1u; - } - return true; -} - -fn find_pos<T:Eq + Clone>(n: T, h: ~[T]) -> Option<uint> { - let mut i = 0u; - for iter(h.clone()) |e| { - if *e == n { return Some(i); } - i += 1u; - } - None -} - -fn bail_deep(x: ~[~[bool]]) { - let mut seen = false; - for iter(x.clone()) |x| { - for iter(x.clone()) |x| { - assert!(!seen); - if *x { seen = true; return; } - } - } - assert!(!seen); -} - -fn ret_deep() -> ~str { - for iter(~[1, 2]) |e| { - for iter(~[3, 4]) |x| { - if *e + *x > 4 { return ~"hi"; } - } - } - return ~"bye"; -} - -pub fn main() { - let mut last = 0; - let v = ~[1, 2, 3, 4, 5, 6, 7]; - for v.iter().all |e| { - last = *e; - if *e == 5 { break; } - if *e % 2 == 1 { loop; } - assert_eq!(*e % 2, 0); - }; - assert_eq!(last, 5); - - assert_eq!(find_pos(1, ~[0, 1, 2, 3]), Some(1u)); - assert_eq!(find_pos(1, ~[0, 4, 2, 3]), None); - assert_eq!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]), Some(3u)); - - bail_deep(~[~[false, false], ~[true, true], ~[false, true]]); - bail_deep(~[~[true]]); - bail_deep(~[~[false, false, false]]); - - assert_eq!(ret_deep(), ~"hi"); -} |