#[lang = "eh_personality"] extern fn eh_personality() {}
# #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
# fn main() {}
+# mod std { // for-loops
+# pub use core::iter;
+# pub use core::option;
+# }
```
Note that there is one extra lang item here which differs from the examples
fn reverse_bits(byte: u8) -> u8 {
let mut result = 0;
- for i in 0..u8::BITS {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0..u8::BITS;
+ while let Some(i) = iter.next() {
result |= ((byte >> i) & 1) << (u8::BITS - 1 - i);
}
result
#[unsafe_destructor]
impl<T> Drop for RawItems<T> {
fn drop(&mut self) {
- for _ in *self {}
+ for _ in self.by_ref() {}
}
}
fn drop(&mut self) {
// We need to cleanup the stored values manually, as the RawItems destructor would run
// after our deallocation.
- for _ in self.keys {}
- for _ in self.vals {}
- for _ in self.edges {}
+ for _ in self.keys.by_ref() {}
+ for _ in self.vals.by_ref() {}
+ for _ in self.edges.by_ref() {}
let (alignment, size) =
calculate_allocation_generic::<K, V>(self.capacity, self.is_leaf);
#![feature(unicode)]
#![feature(hash)]
#![cfg_attr(test, feature(test))]
+// NOTE(stage0): remove after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
#[macro_use]
extern crate core;
pub use core::marker; // derive(Copy)
pub use core::hash; // derive(Hash)
pub use core::ops; // RangeFull
+ // for-loops
+ pub use core::iter;
}
#[cfg(test)]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T: 'a> Drop for Drain<'a, T> {
fn drop(&mut self) {
- for _ in *self {}
+ for _ in self.by_ref() {}
self.inner.head = 0;
self.inner.tail = 0;
}
fn bench_push_back_100(b: &mut test::Bencher) {
let mut deq = RingBuf::with_capacity(101);
b.iter(|| {
- for i in 0i..100 {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0i..100;
+ while let Some(i) = iter.next() {
deq.push_back(i);
}
deq.head = 0;
fn bench_push_front_100(b: &mut test::Bencher) {
let mut deq = RingBuf::with_capacity(101);
b.iter(|| {
- for i in 0i..100 {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0i..100;
+ while let Some(i) = iter.next() {
deq.push_front(i);
}
deq.head = 0;
let mut amt = 0;
let mut it = v.permutations();
let (min_size, max_opt) = it.size_hint();
- for _perm in it {
+ for _perm in it.by_ref() {
amt += 1;
}
assert_eq!(amt, it.swaps.swaps_made);
loop {
match self.state {
Composing => {
- for ch in self.iter {
+ for ch in self.iter.by_ref() {
let ch_class = unicode::char::canonical_combining_class(ch);
if self.composee.is_none() {
if ch_class != 0 {
// zeroed (when moving out, because of #[unsafe_no_drop_flag]).
if self.cap != 0 {
unsafe {
- for x in self.iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = self.iter();
+ while let Some(x) = iter.next() {
ptr::read(x);
}
dealloc(*self.ptr, self.cap)
#[unstable(feature = "collections")]
pub fn into_inner(mut self) -> Vec<T> {
unsafe {
- for _x in self { }
+ for _x in self.by_ref() { }
let IntoIter { allocation, cap, ptr: _ptr, end: _end } = self;
mem::forget(self);
Vec { ptr: NonZero::new(allocation), cap: cap, len: 0 }
fn drop(&mut self) {
// destroy the remaining elements
if self.cap != 0 {
- for _x in *self {}
+ for _x in self.by_ref() {}
unsafe {
dealloc(self.allocation, self.cap);
}
// so we can use #[unsafe_no_drop_flag].
// destroy the remaining elements
- for _x in *self {}
+ for _x in self.by_ref() {}
}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
- for x in *self {
+ for x in self.by_ref() {
if n == 0 { return Some(x) }
n -= 1;
}
/// fn process<U: Iterator<Item=isize>>(it: U) -> isize {
/// let mut it = it.fuse();
/// let mut sum = 0;
- /// for x in it {
+ /// for x in it.by_ref() {
/// if x > 5 {
/// break;
/// }
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
- for x in *self { if f(x) { return true; } }
+ for x in self.by_ref() { if f(x) { return true; } }
false
}
fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
{
- for x in *self {
+ for x in self.by_ref() {
if predicate(&x) { return Some(x) }
}
None
P: FnMut(Self::Item) -> bool,
{
let mut i = 0;
- for x in *self {
+ for x in self.by_ref() {
if predicate(x) {
return Some(i);
}
#[inline]
fn next(&mut self) -> Option<A> {
- for x in self.iter {
+ for x in self.iter.by_ref() {
if (self.predicate)(&x) {
return Some(x);
} else {
#[inline]
fn next(&mut self) -> Option<B> {
- for x in self.iter {
+ for x in self.iter.by_ref() {
match (self.f)(x) {
Some(y) => return Some(y),
None => ()
#[inline]
fn next(&mut self) -> Option<A> {
- for x in self.iter {
+ for x in self.iter.by_ref() {
if self.flag || !(self.predicate)(&x) {
self.flag = true;
return Some(x);
fn next(&mut self) -> Option<B> {
loop {
for inner in self.frontiter.iter_mut() {
- for x in *inner {
+ for x in inner.by_ref() {
return Some(x)
}
}
#![allow(unknown_features)] #![feature(int_uint)]
#![feature(on_unimplemented)]
#![deny(missing_docs)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
#[macro_use]
mod macros;
pub use marker;
pub use ops;
pub use option;
+ // for-loops
+ pub use iter;
}
let mut exp_info = None::<(char, uint)>;
// Parse the integer part of the significand
- for (i, c) in cs {
+ for (i, c) in cs.by_ref() {
match c.to_digit(radix) {
Some(digit) => {
// shift significand one digit left
// part of the significand
if exp_info.is_none() {
let mut power = 1.0;
- for (i, c) in cs {
+ for (i, c) in cs.by_ref() {
match c.to_digit(radix) {
Some(digit) => {
// Decrease power one order of magnitude
pub use core::{option, fmt}; // panic!()
pub use core::clone; // derive Clone
pub use core::marker;
+ // for-loops
+ pub use core::iter;
}
#[cfg(test)]
#![feature(unicode)]
#![feature(hash)]
#![cfg_attr(test, feature(test))]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
extern crate arena;
extern crate flate;
for (word_index, &word) in words.iter().enumerate() {
if word != 0 {
let base_index = word_index * uint::BITS;
- for offset in 0u..uint::BITS {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0u..uint::BITS;
+ while let Some(offset) = iter.next() {
let bit = 1 << offset;
if (word & bit) != 0 {
// NB: we round up the total number of bits
#![feature(std_misc)]
#![feature(unicode)]
#![feature(hash)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
extern crate arena;
extern crate flate;
#![feature(core)]
#![feature(rustc_private)]
#![feature(std_misc)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
#![feature(test)]
#![feature(unicode)]
#![feature(hash)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
extern crate arena;
extern crate getopts;
fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {
let bits = try!(d.read_uint());
let mut set = EnumSet::new();
- for bit in 0..uint::BITS {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0..uint::BITS;
+ while let Some(bit) = iter.next() {
if bits & (1 << bit) != 0 {
set.insert(CLike::from_uint(1 << bit));
}
_ => {
f(b'\\');
f(b'x');
- for &offset in [4u, 0u].iter() {
+ // FIXME(#21245) use a for loop
+ let arr = [4u, 0u];
+ let mut iter = arr.iter();
+ while let ::option::Option::Some(&offset) = ::iter::Iterator::next(&mut iter) {
match ((c as i32) >> offset) & 0xf {
i @ 0 ... 9 => f(b'0' + (i as u8)),
i => f(b'a' + (i as u8 - 10)),
use clone::Clone;
use cmp;
use hash::{Hash, Hasher};
-use iter::{Iterator, ExactSizeIterator, count};
+use iter::{Iterator, IteratorExt, ExactSizeIterator, count};
use marker::{Copy, Sized, self};
use mem::{min_align_of, size_of};
use mem;
#[unsafe_destructor]
impl<'a, K: 'a, V: 'a> Drop for Drain<'a, K, V> {
fn drop(&mut self) {
- for _ in *self {}
+ for _ in self.by_ref() {}
}
}
#![feature(rand)]
#![feature(hash)]
#![cfg_attr(test, feature(test))]
+#![allow(unstable)]
+// NOTE(stage0): remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
// Don't link to std. We are std.
#![no_std]
pub use slice;
pub use boxed; // used for vec![]
+ // for-loops
+ pub use iter;
}
}
(Some(a), Some(_)) => {
comps.push("..");
- for _ in itb {
+ for _ in itb.by_ref() {
comps.push("..");
}
comps.push(a);
}
// start all the tasks
- for tx in txs.iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = txs.iter();
+ while let Some(tx) = iter.next() {
tx.send(()).unwrap();
}
}
let _t = Thread::spawn(move|| {
let mut count = 0;
- for x in rx.iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = rx.iter();
+ while let Some(x) = iter.next() {
if count >= 3 {
break;
} else {
let _t = Thread::spawn(move|| {
let mut count = 0;
- for x in rx.iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = rx.iter();
+ while let Some(x) = iter.next() {
if count >= 3 {
break;
} else {
let tx = tx.clone();
let q = q.clone();
Thread::spawn(move|| {
- for i in 0..nmsgs {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0..nmsgs;
+ while let Some(i) = iter.next() {
q.push(i);
}
tx.send(()).unwrap();
impl<T> MoveMap<T> for Vec<T> {
fn move_map<F>(mut self, mut f: F) -> Vec<T> where F: FnMut(T) -> T {
- for p in self.iter_mut() {
- unsafe {
- // FIXME(#5016) this shouldn't need to zero to be safe.
- ptr::write(p, f(ptr::read_and_zero(p)));
+ // FIXME(#21245) use a for loop
+ {
+ let mut iter = self.iter_mut();
+ while let Some(p) = iter.next() {
+ unsafe {
+ // FIXME(#5016) this shouldn't need to zero to be safe.
+ ptr::write(p, f(ptr::read_and_zero(p)));
+ }
}
}
self
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(unicode)]
+#![allow(unstable)]
+// NOTE(stage0) remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
extern crate arena;
extern crate fmt_macros;
#![feature(rustc_private)]
#![feature(std_misc)]
#![feature(hash)]
+#![allow(unstable)]
+// NOTE(stage0): remove cfg_attr after a snapshot
+#![cfg_attr(not(stage0), allow(unused_mut))]
extern crate getopts;
extern crate serialize;
pub use core::cmp;
pub use core::fmt;
pub use core::marker;
+ // for-loops
+ pub use core::iter;
+ pub use core::option;
}
(i + 1) * chunk_size
};
- for &init_i in vec_init_i[start..end].iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = vec_init_i[start..end].iter();
+ while let Some(&init_i) = iter.next() {
write_line(init_i, init_r_slice, &mut res);
}
}).collect::<Vec<_>>();
try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h));
- for res in data.into_iter() {
+ // FIXME(#21245) use a for loop
+ let mut iter = data.into_iter();
+ while let Some(res) = iter.next() {
try!(out.write(res.join().ok().unwrap().as_slice()));
}
out.flush()
// all unused piece can be placed on the board.
fn is_board_unfeasible(board: u64, masks: &Vec<Vec<Vec<u64>>>) -> bool {
let mut coverable = board;
- for (i, masks_at) in masks.iter().enumerate() {
+ // FIXME(#21245) use a for loop
+ let mut iter = masks.iter().enumerate();
+ while let Some((i, masks_at)) = iter.next() {
if board & 1 << i != 0 { continue; }
for (cur_id, pos_masks) in masks_at.iter().enumerate() {
if board & 1 << (50 + cur_id) != 0 { continue; }
let mut sol = repeat('.' as u8).take(50).collect::<Vec<_>>();
for &m in raw_sol.iter() {
let id = '0' as u8 + get_id(m);
- for i in 0u..50 {
+ // FIXME(#21245) use a for loop
+ let mut iter = 0u..50;
+ while let Some(i) = iter.next() {
if m & 1 << i != 0 {
sol[i] = id;
}
projects / rust.git / commitdiff