// parallel (especially when we have lots and lots of child processes).
// For context, see #8904
io::test::raise_fd_limit();
- let res = test::run_tests_console(&opts, tests.move_iter().collect());
+ let res = test::run_tests_console(&opts, tests.into_iter().collect());
match res {
Ok(true) => {}
Ok(false) => fail!("Some tests failed"),
},
_ => None
}
-}
\ No newline at end of file
+}
let mut cmd = Command::new(prog);
cmd.args(args);
add_target_env(&mut cmd, lib_path, aux_path);
- for (key, val) in env.move_iter() {
+ for (key, val) in env.into_iter() {
cmd.env(key, val);
}
let mut cmd = Command::new(prog);
cmd.args(args);
add_target_env(&mut cmd, lib_path, aux_path);
- for (key, val) in env.move_iter() {
+ for (key, val) in env.into_iter() {
cmd.env(key, val);
}
"--debuginfo".to_string()
];
let new_options =
- split_maybe_args(options).move_iter()
+ split_maybe_args(options).into_iter()
.filter(|x| !options_to_remove.contains(x))
.collect::<Vec<String>>()
.connect(" ");
// run test via adb_run_wrapper
runargs.push("shell".to_string());
- for (key, val) in env.move_iter() {
+ for (key, val) in env.into_iter() {
runargs.push(format!("{}={}", key, val));
}
runargs.push(format!("{}/adb_run_wrapper.sh", config.adb_test_dir));
let mut futures = Vec::from_fn(1000, |ind| Future::spawn( proc() { partial_sum(ind) }));
let mut final_res = 0f64;
- for ft in futures.mut_iter() {
+ for ft in futures.iter_mut() {
final_res += ft.get();
}
println!("Ï€^2/6 is not far from : {}", final_res);
Rust does not have the "C style" `for` loop on purpose. Manually controlling
each element of the loop is complicated and error prone, even for experienced C
-developers.
+developers.
We'll talk more about `for` when we cover **iterator**s, later in the Guide.
#[cfg(jemalloc)]
mod imp {
use core::option::{None, Option};
- use core::ptr::{RawPtr, mut_null, null};
+ use core::ptr::{RawPtr, null_mut, null};
use core::num::Int;
use libc::{c_char, c_int, c_void, size_t};
use super::MIN_ALIGN;
pub fn stats_print() {
unsafe {
- je_malloc_stats_print(None, mut_null(), null())
+ je_malloc_stats_print(None, null_mut(), null())
}
}
}
//! The global (exchange) heap.
use libc::{c_void, size_t, free, malloc, realloc};
-use core::ptr::{RawPtr, mut_null};
+use core::ptr::{RawPtr, null_mut};
/// A wrapper around libc::malloc, aborting on out-of-memory.
#[inline]
// `malloc(0)` may allocate, but it may also return a null pointer
// http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html
if size == 0 {
- mut_null()
+ null_mut()
} else {
let p = malloc(size as size_t);
if p.is_null() {
// http://pubs.opengroup.org/onlinepubs/9699919799/functions/realloc.html
if size == 0 {
free(ptr as *mut c_void);
- mut_null()
+ null_mut()
} else {
let p = realloc(ptr as *mut c_void, size as size_t);
if p.is_null() {
#[inline]
pub fn with_capacity(capacity: uint) -> TypedArena<T> {
unsafe {
- let chunk = TypedArenaChunk::<T>::new(ptr::mut_null(), capacity);
+ let chunk = TypedArenaChunk::<T>::new(ptr::null_mut(), capacity);
TypedArena {
ptr: Cell::new((*chunk).start() as *const T),
end: Cell::new((*chunk).end() as *const T),
// `op` is a bitwise operation, since any bits that should've
// been masked were fine to change anyway. `b` is masked to
// make sure its unmasked bits do not cause damage.
- for (a, (_, b)) in self.storage.mut_iter()
+ for (a, (_, b)) in self.storage.iter_mut()
.zip(other.mask_words(0)) {
let w = op(*a, b);
if *a != w {
/// ```
#[inline]
pub fn set_all(&mut self) {
- for w in self.storage.mut_iter() { *w = !0u; }
+ for w in self.storage.iter_mut() { *w = !0u; }
}
/// Flips all bits.
/// ```
#[inline]
pub fn negate(&mut self) {
- for w in self.storage.mut_iter() { *w = !*w; }
+ for w in self.storage.iter_mut() { *w = !*w; }
}
/// Calculates the union of two bitvectors. This acts like the bitwise `or`
impl Mutable for Bitv {
#[inline]
fn clear(&mut self) {
- for w in self.storage.mut_iter() { *w = 0u; }
+ for w in self.storage.iter_mut() { *w = 0u; }
}
}
fn clone_from(&mut self, source: &Bitv) {
self.nbits = source.nbits;
self.storage.reserve(source.storage.len());
- for (i, w) in self.storage.mut_iter().enumerate() { *w = source.storage[i]; }
+ for (i, w) in self.storage.iter_mut().enumerate() { *w = source.storage[i]; }
}
}
impl<T> Rawlink<T> {
/// Like Option::None for Rawlink
fn none() -> Rawlink<T> {
- Rawlink{p: ptr::mut_null()}
+ Rawlink{p: ptr::null_mut()}
}
/// Like Option::Some for Rawlink
/// ```
pub fn insert_when(&mut self, elt: T, f: |&T, &T| -> bool) {
{
- let mut it = self.mut_iter();
+ let mut it = self.iter_mut();
loop {
match it.peek_next() {
None => break,
/// This operation should compute in O(max(N, M)) time.
pub fn merge(&mut self, mut other: DList<T>, f: |&T, &T| -> bool) {
{
- let mut it = self.mut_iter();
+ let mut it = self.iter_mut();
loop {
let take_a = match (it.peek_next(), other.front()) {
(_ , None) => return,
check_links(&m);
let sum = v.append(u.as_slice());
assert_eq!(sum.len(), m.len());
- for elt in sum.move_iter() {
+ for elt in sum.into_iter() {
assert_eq!(m.pop_front(), Some(elt))
}
}
check_links(&m);
let sum = u.append(v.as_slice());
assert_eq!(sum.len(), m.len());
- for elt in sum.move_iter() {
+ for elt in sum.into_iter() {
assert_eq!(m.pop_front(), Some(elt))
}
}
m.rotate_backward(); check_links(&m);
m.push_front(9); check_links(&m);
m.rotate_forward(); check_links(&m);
- assert_eq!(vec![3i,9,5,1,2], m.move_iter().collect());
+ assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect());
}
#[test]
fn test_mut_iter() {
let mut m = generate_test();
let mut len = m.len();
- for (i, elt) in m.mut_iter().enumerate() {
+ for (i, elt) in m.iter_mut().enumerate() {
assert_eq!(i as int, *elt);
len -= 1;
}
assert_eq!(len, 0);
let mut n = DList::new();
- assert!(n.mut_iter().next().is_none());
+ assert!(n.iter_mut().next().is_none());
n.push_front(4i);
n.push(5);
- let mut it = n.mut_iter();
+ let mut it = n.iter_mut();
assert_eq!(it.size_hint(), (2, Some(2)));
assert!(it.next().is_some());
assert!(it.next().is_some());
#[test]
fn test_iterator_mut_double_end() {
let mut n = DList::new();
- assert!(n.mut_iter().next_back().is_none());
+ assert!(n.iter_mut().next_back().is_none());
n.push_front(4i);
n.push_front(5);
n.push_front(6);
- let mut it = n.mut_iter();
+ let mut it = n.iter_mut();
assert_eq!(it.size_hint(), (3, Some(3)));
assert_eq!(*it.next().unwrap(), 6);
assert_eq!(it.size_hint(), (2, Some(2)));
let mut m = list_from(&[0i,2,4,6,8]);
let len = m.len();
{
- let mut it = m.mut_iter();
+ let mut it = m.iter_mut();
it.insert_next(-2);
loop {
match it.next() {
}
check_links(&m);
assert_eq!(m.len(), 3 + len * 2);
- assert_eq!(m.move_iter().collect::<Vec<int>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
+ assert_eq!(m.into_iter().collect::<Vec<int>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
}
#[test]
m.merge(n, |a, b| a <= b);
assert_eq!(m.len(), len);
check_links(&m);
- let res = m.move_iter().collect::<Vec<int>>();
+ let res = m.into_iter().collect::<Vec<int>>();
assert_eq!(res, vec![-1, 0, 0, 0, 1, 3, 5, 6, 7, 2, 7, 7, 9]);
}
m.push(4);
m.insert_ordered(3);
check_links(&m);
- assert_eq!(vec![2,3,4], m.move_iter().collect::<Vec<int>>());
+ assert_eq!(vec![2,3,4], m.into_iter().collect::<Vec<int>>());
}
#[test]
fn test_mut_rev_iter() {
let mut m = generate_test();
- for (i, elt) in m.mut_iter().rev().enumerate() {
+ for (i, elt) in m.iter_mut().rev().enumerate() {
assert_eq!((6-i) as int, *elt);
}
let mut n = DList::new();
- assert!(n.mut_iter().rev().next().is_none());
+ assert!(n.iter_mut().rev().next().is_none());
n.push_front(4i);
- let mut it = n.mut_iter().rev();
+ let mut it = n.iter_mut().rev();
assert!(it.next().is_some());
assert!(it.next().is_none());
}
check_links(&m);
let mut i = 0u;
- for (a, &b) in m.move_iter().zip(v.iter()) {
+ for (a, &b) in m.into_iter().zip(v.iter()) {
i += 1;
assert_eq!(a, b);
}
let v = &[0i, ..128];
let mut m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
- assert!(m.mut_iter().count() == 128);
+ assert!(m.iter_mut().count() == 128);
})
}
#[bench]
let v = &[0i, ..128];
let mut m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
- assert!(m.mut_iter().rev().count() == 128);
+ assert!(m.iter_mut().rev().count() == 128);
})
}
}
impl<T> Mutable for RingBuf<T> {
/// Clears the `RingBuf`, removing all values.
fn clear(&mut self) {
- for x in self.elts.mut_iter() { *x = None }
+ for x in self.elts.iter_mut() { *x = None }
self.nelts = 0;
self.lo = 0;
}
/// buf.push(5i);
/// buf.push(3);
/// buf.push(4);
- /// for num in buf.mut_iter() {
+ /// for num in buf.iter_mut() {
/// *num = *num - 2;
/// }
/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
- /// assert_eq!(buf.mut_iter().collect::<Vec<&mut int>>().as_slice(), b);
+ /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>().as_slice(), b);
/// ```
pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
let start_index = raw_index(self.lo, self.elts.len(), 0);
// start_index to self.elts.len()
// and then
// 0 to end_index
- let (temp, remaining1) = self.elts.mut_split_at(start_index);
- let (remaining2, _) = temp.mut_split_at(end_index);
+ let (temp, remaining1) = self.elts.split_at_mut(start_index);
+ let (remaining2, _) = temp.split_at_mut(end_index);
MutItems { remaining1: remaining1,
remaining2: remaining2,
nelts: self.nelts }
} else {
// Items to iterate goes from start_index to end_index:
- let (empty, elts) = self.elts.mut_split_at(0);
- let remaining1 = elts.mut_slice(start_index, end_index);
+ let (empty, elts) = self.elts.split_at_mut(0);
+ let remaining1 = elts.slice_mut(start_index, end_index);
MutItems { remaining1: remaining1,
remaining2: empty,
nelts: self.nelts }
#[test]
fn test_mut_rev_iter_wrap() {
let mut d = RingBuf::with_capacity(3);
- assert!(d.mut_iter().rev().next().is_none());
+ assert!(d.iter_mut().rev().next().is_none());
d.push(1i);
d.push(2);
assert_eq!(d.pop_front(), Some(1));
d.push(4);
- assert_eq!(d.mut_iter().rev().map(|x| *x).collect::<Vec<int>>(),
+ assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<int>>(),
vec!(4, 3, 2));
}
#[test]
fn test_mut_iter() {
let mut d = RingBuf::new();
- assert!(d.mut_iter().next().is_none());
+ assert!(d.iter_mut().next().is_none());
for i in range(0u, 3) {
d.push_front(i);
}
- for (i, elt) in d.mut_iter().enumerate() {
+ for (i, elt) in d.iter_mut().enumerate() {
assert_eq!(*elt, 2 - i);
*elt = i;
}
{
- let mut it = d.mut_iter();
+ let mut it = d.iter_mut();
assert_eq!(*it.next().unwrap(), 0);
assert_eq!(*it.next().unwrap(), 1);
assert_eq!(*it.next().unwrap(), 2);
#[test]
fn test_mut_rev_iter() {
let mut d = RingBuf::new();
- assert!(d.mut_iter().rev().next().is_none());
+ assert!(d.iter_mut().rev().next().is_none());
for i in range(0u, 3) {
d.push_front(i);
}
- for (i, elt) in d.mut_iter().rev().enumerate() {
+ for (i, elt) in d.iter_mut().rev().enumerate() {
assert_eq!(*elt, i);
*elt = i;
}
{
- let mut it = d.mut_iter().rev();
+ let mut it = d.iter_mut().rev();
assert_eq!(*it.next().unwrap(), 0);
assert_eq!(*it.next().unwrap(), 1);
assert_eq!(*it.next().unwrap(), 2);
//! }
//! ```
//!
-//! * `.mut_iter()` returns an iterator that allows modifying each value.
+//! * `.iter_mut()` returns an iterator that allows modifying each value.
//! * Further iterators exist that split, chunk or permute the slice.
#![doc(primitive = "slice")]
self.sdir.as_mut_slice().swap(i, j);
// Swap the direction of each larger SizeDirection
- for x in self.sdir.mut_iter() {
+ for x in self.sdir.iter_mut() {
if x.size > sd.size {
x.dir = match x.dir { Pos => Neg, Neg => Pos };
}
#[inline]
fn move_from(self, mut src: Vec<T>, start: uint, end: uint) -> uint {
- for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
+ for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) {
mem::swap(a, b);
}
cmp::min(self.len(), end-start)
self.swap(j, i-1);
// Step 4: Reverse the (previously) weakly decreasing part
- self.mut_slice_from(i).reverse();
+ self.slice_from_mut(i).reverse();
true
}
}
// Step 2: Reverse the weakly increasing part
- self.mut_slice_from(i).reverse();
+ self.slice_from_mut(i).reverse();
// Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
let mut j = self.len() - 1;
fn test_iter_size_hints() {
let mut xs = [1i, 2, 5, 10, 11];
assert_eq!(xs.iter().size_hint(), (5, Some(5)));
- assert_eq!(xs.mut_iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
}
#[test]
#[test]
fn test_mut_iterator() {
let mut xs = [1i, 2, 3, 4, 5];
- for x in xs.mut_iter() {
+ for x in xs.iter_mut() {
*x += 1;
}
assert!(xs == [2, 3, 4, 5, 6])
#[test]
fn test_mut_rev_iterator() {
let mut xs = [1u, 2, 3, 4, 5];
- for (i,x) in xs.mut_iter().rev().enumerate() {
+ for (i,x) in xs.iter_mut().rev().enumerate() {
*x += i;
}
assert!(xs == [5, 5, 5, 5, 5])
#[test]
fn test_move_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.move_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
+ assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
}
#[test]
fn test_move_rev_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.move_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
+ assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
}
#[test]
assert!(a == [7i,2,3,4]);
let mut a = [1i,2,3,4,5];
let b = vec![5i,6,7,8,9,0];
- assert_eq!(a.mut_slice(2,4).move_from(b,1,6), 2);
+ assert_eq!(a.slice_mut(2,4).move_from(b,1,6), 2);
assert!(a == [1i,2,6,7,5]);
}
#[test]
fn test_reverse_part() {
let mut values = [1i,2,3,4,5];
- values.mut_slice(1, 4).reverse();
+ values.slice_mut(1, 4).reverse();
assert!(values == [1,4,3,2,5]);
}
fn test_bytes_set_memory() {
use slice::bytes::MutableByteVector;
let mut values = [1u8,2,3,4,5];
- values.mut_slice(0,5).set_memory(0xAB);
+ values.slice_mut(0,5).set_memory(0xAB);
assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
- values.mut_slice(2,4).set_memory(0xFF);
+ values.slice_mut(2,4).set_memory(0xFF);
assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
}
fn test_mut_split_at() {
let mut values = [1u8,2,3,4,5];
{
- let (left, right) = values.mut_split_at(2);
+ let (left, right) = values.split_at_mut(2);
assert!(left.slice(0, left.len()) == [1, 2]);
- for p in left.mut_iter() {
+ for p in left.iter_mut() {
*p += 1;
}
assert!(right.slice(0, right.len()) == [3, 4, 5]);
- for p in right.mut_iter() {
+ for p in right.iter_mut() {
*p += 2;
}
}
}
assert_eq!(cnt, 5);
- for f in v.mut_iter() {
+ for f in v.iter_mut() {
assert!(*f == Foo);
cnt += 1;
}
assert_eq!(cnt, 8);
- for f in v.move_iter() {
+ for f in v.into_iter() {
assert!(f == Foo);
cnt += 1;
}
#[test]
fn test_mut_splitator() {
let mut xs = [0i,1,0,2,3,0,0,4,5,0];
- assert_eq!(xs.mut_split(|x| *x == 0).count(), 6);
- for slice in xs.mut_split(|x| *x == 0) {
+ assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
+ for slice in xs.split_mut(|x| *x == 0) {
slice.reverse();
}
assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
let mut xs = [0i,1,0,2,3,0,0,4,5,0,6,7];
- for slice in xs.mut_split(|x| *x == 0).take(5) {
+ for slice in xs.split_mut(|x| *x == 0).take(5) {
slice.reverse();
}
assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
#[test]
fn test_mut_splitator_rev() {
let mut xs = [1i,2,0,3,4,0,0,5,6,0];
- for slice in xs.mut_split(|x| *x == 0).rev().take(4) {
+ for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
slice.reverse();
}
assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
#[test]
fn test_mut_chunks() {
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
- for (i, chunk) in v.mut_chunks(3).enumerate() {
- for x in chunk.mut_iter() {
+ for (i, chunk) in v.chunks_mut(3).enumerate() {
+ for x in chunk.iter_mut() {
*x = i as u8;
}
}
#[test]
fn test_mut_chunks_rev() {
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
- for (i, chunk) in v.mut_chunks(3).rev().enumerate() {
- for x in chunk.mut_iter() {
+ for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
+ for x in chunk.iter_mut() {
*x = i as u8;
}
}
#[should_fail]
fn test_mut_chunks_0() {
let mut v = [1i, 2, 3, 4];
- let _it = v.mut_chunks(0);
+ let _it = v.chunks_mut(0);
}
#[test]
#[test]
fn test_mut_last() {
let mut x = [1i, 2, 3, 4, 5];
- let h = x.mut_last();
+ let h = x.last_mut();
assert_eq!(*h.unwrap(), 5);
let y: &mut [int] = [];
- assert!(y.mut_last().is_none());
+ assert!(y.last_mut().is_none());
}
}
b.iter(|| {
let mut i = 0i;
- for x in v.mut_iter() {
+ for x in v.iter_mut() {
*x = i;
i += 1;
}
unsafe {
v.set_len(1024);
}
- for x in v.mut_iter() {
+ for x in v.iter_mut() {
*x = 0i;
}
v
#[inline]
fn clone_from(&mut self, source: &SmallIntMap<V>) {
self.v.reserve(source.v.len());
- for (i, w) in self.v.mut_iter().enumerate() {
+ for (i, w) in self.v.iter_mut().enumerate() {
*w = source.v[i].clone();
}
}
/// map.insert(2, "b");
/// map.insert(3, "c");
///
- /// for (key, value) in map.mut_iter() {
+ /// for (key, value) in map.iter_mut() {
/// *value = "x";
/// }
///
MutEntries {
front: 0,
back: self.v.len(),
- iter: self.v.mut_iter()
+ iter: self.v.iter_mut()
}
}
/// map.insert(2, "b");
///
/// // Not possible with .iter()
- /// let vec: Vec<(uint, &str)> = map.move_iter().collect();
+ /// let vec: Vec<(uint, &str)> = map.into_iter().collect();
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
Enumerate<vec::MoveItems<Option<V>>>>
{
let values = replace(&mut self.v, vec!());
- values.move_iter().enumerate().filter_map(|(i, v)| {
+ values.into_iter().enumerate().filter_map(|(i, v)| {
v.map(|v| (i, v))
})
}
assert_eq!(m.iter().size_hint(), (0, Some(11)));
assert_eq!(m.iter().rev().size_hint(), (0, Some(11)));
- assert_eq!(m.mut_iter().size_hint(), (0, Some(11)));
- assert_eq!(m.mut_iter().rev().size_hint(), (0, Some(11)));
+ assert_eq!(m.iter_mut().size_hint(), (0, Some(11)));
+ assert_eq!(m.iter_mut().rev().size_hint(), (0, Some(11)));
}
#[test]
assert!(m.insert(6, 10));
assert!(m.insert(10, 11));
- for (k, v) in m.mut_iter() {
+ for (k, v) in m.iter_mut() {
*v += k as int;
}
assert!(m.insert(6, 10));
assert!(m.insert(10, 11));
- for (k, v) in m.mut_iter().rev() {
+ for (k, v) in m.iter_mut().rev() {
*v += k as int;
}
let mut m = SmallIntMap::new();
m.insert(1, box 2i);
let mut called = false;
- for (k, v) in m.move_iter() {
+ for (k, v) in m.into_iter() {
assert!(!called);
called = true;
assert_eq!(k, 1);
/// map.insert("b", 2i);
///
/// // Add 10 until we find "b"
- /// for (key, value) in map.mut_iter() {
+ /// for (key, value) in map.iter_mut() {
/// *value += 10;
/// if key == &"b" { break }
/// }
/// map.insert("b", 2i);
///
/// // Add 10 until we find "b"
- /// for (key, value) in map.mut_rev_iter() {
+ /// for (key, value) in map.rev_iter_mut() {
/// *value += 10;
/// if key == &"b" { break }
/// }
/// assert_eq!(map.find(&"c"), Some(&13));
/// ```
pub fn rev_iter_mut<'a>(&'a mut self) -> RevMutEntries<'a, K, V> {
- RevMutEntries{iter: self.mut_iter()}
+ RevMutEntries{iter: self.iter_mut()}
}
/// Deprecated: use `into_iter`.
- #[depreated = "use into_iter"]
+ #[deprecated = "use into_iter"]
pub fn move_iter(self) -> MoveEntries<K, V> {
self.into_iter()
}
/// map.insert("b", 2i);
///
/// // Not possible with a regular `.iter()`
- /// let vec: Vec<(&str, int)> = map.move_iter().collect();
+ /// let vec: Vec<(&str, int)> = map.into_iter().collect();
/// assert_eq!(vec, vec![("a", 1), ("b", 2), ("c", 3)]);
/// ```
pub fn into_iter(self) -> MoveEntries<K, V> {
/// t.insert("User-Agent", "Curl-Rust/0.1");
///
/// let new_ua = "Safari/156.0";
- /// match t.find_mut_with(|k| "User-Agent".cmp(k)) {
+ /// match t.find_with_mut(|k| "User-Agent".cmp(k)) {
/// Some(x) => *x = new_ua,
/// None => fail!(),
/// }
/// map.insert(6, "c");
/// map.insert(8, "d");
///
- /// assert_eq!(map.mut_lower_bound(&4).next(), Some((&4, &mut "b")));
- /// assert_eq!(map.mut_lower_bound(&5).next(), Some((&6, &mut "c")));
- /// assert_eq!(map.mut_lower_bound(&10).next(), None);
+ /// assert_eq!(map.lower_bound_mut(&4).next(), Some((&4, &mut "b")));
+ /// assert_eq!(map.lower_bound_mut(&5).next(), Some((&6, &mut "c")));
+ /// assert_eq!(map.lower_bound_mut(&10).next(), None);
///
- /// for (key, value) in map.mut_lower_bound(&4) {
+ /// for (key, value) in map.lower_bound_mut(&4) {
/// *value = "changed";
/// }
///
/// map.insert(6, "c");
/// map.insert(8, "d");
///
- /// assert_eq!(map.mut_upper_bound(&4).next(), Some((&6, &mut "c")));
- /// assert_eq!(map.mut_upper_bound(&5).next(), Some((&6, &mut "c")));
- /// assert_eq!(map.mut_upper_bound(&10).next(), None);
+ /// assert_eq!(map.upper_bound_mut(&4).next(), Some((&6, &mut "c")));
+ /// assert_eq!(map.upper_bound_mut(&5).next(), Some((&6, &mut "c")));
+ /// assert_eq!(map.upper_bound_mut(&10).next(), None);
///
- /// for (key, value) in map.mut_upper_bound(&4) {
+ /// for (key, value) in map.upper_bound_mut(&4) {
/// *value = "changed";
/// }
///
let n: &mut TreeNode<K, V> = &mut **n;
n as *mut TreeNode<K, V>
}
- None => ptr::mut_null()
+ None => ptr::null_mut()
}
}
/// let set: TreeSet<int> = [1i, 4, 3, 5, 2].iter().map(|&x| x).collect();
///
/// // Not possible with a regular `.iter()`
- /// let v: Vec<int> = set.move_iter().collect();
+ /// let v: Vec<int> = set.into_iter().collect();
/// assert_eq!(v, vec![1, 2, 3, 4, 5]);
/// ```
#[inline]
fn heir_swap<K: Ord, V>(node: &mut Box<TreeNode<K, V>>,
child: &mut Option<Box<TreeNode<K, V>>>) {
// *could* be done without recursion, but it won't borrow check
- for x in child.mut_iter() {
+ for x in child.iter_mut() {
if x.right.is_some() {
heir_swap(node, &mut x.right);
} else {
if right_level > save.level {
let save_level = save.level;
- for x in save.right.mut_iter() { x.level = save_level }
+ for x in save.right.iter_mut() { x.level = save_level }
}
skew(save);
- for right in save.right.mut_iter() {
+ for right in save.right.iter_mut() {
skew(right);
- for x in right.right.mut_iter() { skew(x) }
+ for x in right.right.iter_mut() { skew(x) }
}
split(save);
- for x in save.right.mut_iter() { split(x) }
+ for x in save.right.iter_mut() { split(x) }
}
return ret;
assert!(m.insert("t2", 8));
assert!(m.insert("t5", 14));
let new = 100;
- match m.find_mut_with(|k| "t5".cmp(k)) {
+ match m.find_with_mut(|k| "t5".cmp(k)) {
None => fail!(), Some(x) => *x = new
}
assert_eq!(m.find_with(|k| "t5".cmp(k)), Some(&new));
assert!(m.insert(i, 100 * i));
}
- for (i, (&k, v)) in m.mut_iter().enumerate() {
+ for (i, (&k, v)) in m.iter_mut().enumerate() {
*v += k * 10 + i; // 000 + 00 + 0, 100 + 10 + 1, ...
}
assert!(m.insert(i, 100 * i));
}
- for (i, (&k, v)) in m.mut_rev_iter().enumerate() {
+ for (i, (&k, v)) in m.rev_iter_mut().enumerate() {
*v += k * 10 + (9 - i); // 900 + 90 + (9 - 0), 800 + 80 + (9 - 1), ...
}
}
for i in range(1i, 199) {
- let mut lb_it = m_lower.mut_lower_bound(&i);
+ let mut lb_it = m_lower.lower_bound_mut(&i);
let (&k, v) = lb_it.next().unwrap();
let lb = i + i % 2;
assert_eq!(lb, k);
*v -= k;
}
for i in range(0i, 198) {
- let mut ub_it = m_upper.mut_upper_bound(&i);
+ let mut ub_it = m_upper.upper_bound_mut(&i);
let (&k, v) = ub_it.next().unwrap();
let ub = i + 2 - i % 2;
assert_eq!(ub, k);
*v -= k;
}
- assert!(m_lower.mut_lower_bound(&199).next().is_none());
+ assert!(m_lower.lower_bound_mut(&199).next().is_none());
- assert!(m_upper.mut_upper_bound(&198).next().is_none());
+ assert!(m_upper.upper_bound_mut(&198).next().is_none());
assert!(m_lower.iter().all(|(_, &x)| x == 0));
assert!(m_upper.iter().all(|(_, &x)| x == 0));
#[test]
fn test_keys() {
let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
- let map = vec.move_iter().collect::<TreeMap<int, char>>();
+ let map = vec.into_iter().collect::<TreeMap<int, char>>();
let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
#[test]
fn test_values() {
let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
- let map = vec.move_iter().collect::<TreeMap<int, char>>();
+ let map = vec.into_iter().collect::<TreeMap<int, char>>();
let values = map.values().map(|&v| v).collect::<Vec<char>>();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
let s: TreeSet<int> = range(0i, 5).collect();
let mut n = 0;
- for x in s.move_iter() {
+ for x in s.into_iter() {
assert_eq!(x, n);
n += 1;
}
#[test]
fn test_move_iter_size_hint() {
- let s: TreeSet<int> = vec!(0i, 1).move_iter().collect();
+ let s: TreeSet<int> = vec!(0i, 1).into_iter().collect();
- let mut it = s.move_iter();
+ let mut it = s.into_iter();
assert_eq!(it.size_hint(), (2, Some(2)));
assert!(it.next() != None);
/// use std::collections::TrieMap;
/// let mut map: TrieMap<int> = [(1, 2), (2, 4), (3, 6)].iter().map(|&x| x).collect();
///
- /// for (key, value) in map.mut_iter() {
+ /// for (key, value) in map.iter_mut() {
/// *value = -(key as int);
/// }
///
/// ```
pub fn iter_mut<'a>(&'a mut self) -> MutEntries<'a, T> {
let mut iter = unsafe {MutEntries::new()};
- iter.stack[0] = self.root.children.mut_iter();
+ iter.stack[0] = self.root.children.iter_mut();
iter.length = 1;
iter.remaining_min = self.length;
iter.remaining_max = self.length;
/// use std::collections::TrieMap;
/// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
///
- /// assert_eq!(map.mut_lower_bound(4).next(), Some((4, &mut "b")));
- /// assert_eq!(map.mut_lower_bound(5).next(), Some((6, &mut "c")));
- /// assert_eq!(map.mut_lower_bound(10).next(), None);
+ /// assert_eq!(map.lower_bound_mut(4).next(), Some((4, &mut "b")));
+ /// assert_eq!(map.lower_bound_mut(5).next(), Some((6, &mut "c")));
+ /// assert_eq!(map.lower_bound_mut(10).next(), None);
///
- /// for (key, value) in map.mut_lower_bound(4) {
+ /// for (key, value) in map.lower_bound_mut(4) {
/// *value = "changed";
/// }
///
/// use std::collections::TrieMap;
/// let mut map: TrieMap<&str> = [(2, "a"), (4, "b"), (6, "c")].iter().map(|&x| x).collect();
///
- /// assert_eq!(map.mut_upper_bound(4).next(), Some((6, &mut "c")));
- /// assert_eq!(map.mut_upper_bound(5).next(), Some((6, &mut "c")));
- /// assert_eq!(map.mut_upper_bound(10).next(), None);
+ /// assert_eq!(map.upper_bound_mut(4).next(), Some((6, &mut "c")));
+ /// assert_eq!(map.upper_bound_mut(5).next(), Some((6, &mut "c")));
+ /// assert_eq!(map.upper_bound_mut(10).next(), None);
///
- /// for (key, value) in map.mut_upper_bound(4) {
+ /// for (key, value) in map.upper_bound_mut(4) {
/// *value = "changed";
/// }
///
#[test]
fn test_keys() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.move_iter().collect::<TrieMap<char>>();
+ let map = vec.into_iter().collect::<TrieMap<char>>();
let keys = map.keys().collect::<Vec<uint>>();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
#[test]
fn test_values() {
let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
- let map = vec.move_iter().collect::<TrieMap<char>>();
+ let map = vec.into_iter().collect::<TrieMap<char>>();
let values = map.values().map(|&v| v).collect::<Vec<char>>();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
#[test]
fn test_mut_iter() {
let mut empty_map : TrieMap<uint> = TrieMap::new();
- assert!(empty_map.mut_iter().next().is_none());
+ assert!(empty_map.iter_mut().next().is_none());
let first = uint::MAX - 10000;
let last = uint::MAX;
}
let mut i = 0;
- for (k, v) in map.mut_iter() {
+ for (k, v) in map.iter_mut() {
assert_eq!(k, first + i);
*v -= k / 2;
i += 1;
}
for i in range(0u, 199) {
- let mut lb_it = m_lower.mut_lower_bound(i);
+ let mut lb_it = m_lower.lower_bound_mut(i);
let (k, v) = lb_it.next().unwrap();
let lb = i + i % 2;
assert_eq!(lb, k);
}
for i in range(0u, 198) {
- let mut ub_it = m_upper.mut_upper_bound(i);
+ let mut ub_it = m_upper.upper_bound_mut(i);
let (k, v) = ub_it.next().unwrap();
let ub = i + 2 - i % 2;
assert_eq!(ub, k);
*v -= k;
}
- assert!(m_lower.mut_lower_bound(199).next().is_none());
- assert!(m_upper.mut_upper_bound(198).next().is_none());
+ assert!(m_lower.lower_bound_mut(199).next().is_none());
+ assert!(m_upper.upper_bound_mut(198).next().is_none());
assert!(m_lower.iter().all(|(_, &x)| x == 0));
assert!(m_upper.iter().all(|(_, &x)| x == 0));
let mut xs = Vec::with_capacity(length);
while xs.len < length {
let len = xs.len;
- ptr::write(xs.as_mut_slice().unsafe_mut_ref(len), op(len));
+ ptr::write(xs.as_mut_slice().unsafe_mut(len), op(len));
xs.len += 1;
}
xs
let mut lefts = Vec::new();
let mut rights = Vec::new();
- for elt in self.move_iter() {
+ for elt in self.into_iter() {
if f(&elt) {
lefts.push(elt);
} else {
let mut xs = Vec::with_capacity(length);
while xs.len < length {
let len = xs.len;
- ptr::write(xs.as_mut_slice().unsafe_mut_ref(len),
+ ptr::write(xs.as_mut_slice().unsafe_mut(len),
value.clone());
xs.len += 1;
}
// during the loop can prevent this optimisation.
unsafe {
ptr::write(
- self.as_mut_slice().unsafe_mut_ref(len),
+ self.as_mut_slice().unsafe_mut(len),
other.unsafe_get(i).clone());
self.set_len(len + 1);
}
}
// reuse the contained values' allocations/resources.
- for (place, thing) in self.mut_iter().zip(other.iter()) {
+ for (place, thing) in self.iter_mut().zip(other.iter()) {
place.clone_from(thing)
}
///
/// ```
/// let v = vec!["a".to_string(), "b".to_string()];
- /// for s in v.move_iter() {
+ /// for s in v.into_iter() {
/// // s has type String, not &String
/// println!("{}", s);
/// }
///
/// ```
/// let mut vec = vec![1i, 2, 3];
- /// for num in vec.mut_iter() {
+ /// for num in vec.iter_mut() {
/// *num = 0;
/// }
/// ```
#[inline]
pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a,T> {
- self.as_mut_slice().mut_iter()
+ self.as_mut_slice().iter_mut()
}
/// Sorts the vector, in place, using `compare` to compare elements.
///
/// ```
/// let mut vec = vec![1i, 2, 3];
- /// *vec.mut_last().unwrap() = 4;
+ /// *vec.last_mut().unwrap() = 4;
/// assert_eq!(vec, vec![1i, 2, 4]);
/// ```
#[inline]
pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> {
- self.as_mut_slice().mut_last()
+ self.as_mut_slice().last_mut()
}
/// Removes an element from anywhere in the vector and return it, replacing
/// ```
#[inline]
pub fn push_all_move(&mut self, other: Vec<T>) {
- self.extend(other.move_iter());
+ self.extend(other.into_iter());
}
/// Deprecated: use `slice_mut`.
///
/// ```
/// let mut vec = vec![1i, 2, 3, 4];
- /// assert!(vec.mut_slice(0, 2) == [1, 2]);
+ /// assert!(vec.slice_mut(0, 2) == [1, 2]);
/// ```
#[inline]
pub fn slice_mut<'a>(&'a mut self, start: uint, end: uint)
-> &'a mut [T] {
- self.as_mut_slice().mut_slice(start, end)
+ self.as_mut_slice().slice_mut(start, end)
}
/// Deprecated: use "slice_from_mut".
///
/// ```
/// let mut vec = vec![1i, 2, 3, 4];
- /// assert!(vec.mut_slice_from(2) == [3, 4]);
+ /// assert!(vec.slice_from_mut(2) == [3, 4]);
/// ```
#[inline]
pub fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
- self.as_mut_slice().mut_slice_from(start)
+ self.as_mut_slice().slice_from_mut(start)
}
/// Deprecated: use `slice_to_mut`.
///
/// ```
/// let mut vec = vec![1i, 2, 3, 4];
- /// assert!(vec.mut_slice_to(2) == [1, 2]);
+ /// assert!(vec.slice_to_mut(2) == [1, 2]);
/// ```
#[inline]
pub fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
- self.as_mut_slice().mut_slice_to(end)
+ self.as_mut_slice().slice_to_mut(end)
}
/// Deprecated: use `split_at_mut`.
///
/// // scoped to restrict the lifetime of the borrows
/// {
- /// let (left, right) = vec.mut_split_at(0);
+ /// let (left, right) = vec.split_at_mut(0);
/// assert!(left == &mut []);
/// assert!(right == &mut [1, 2, 3, 4, 5, 6]);
/// }
///
/// {
- /// let (left, right) = vec.mut_split_at(2);
+ /// let (left, right) = vec.split_at_mut(2);
/// assert!(left == &mut [1, 2]);
/// assert!(right == &mut [3, 4, 5, 6]);
/// }
///
/// {
- /// let (left, right) = vec.mut_split_at(6);
+ /// let (left, right) = vec.split_at_mut(6);
/// assert!(left == &mut [1, 2, 3, 4, 5, 6]);
/// assert!(right == &mut []);
/// }
/// ```
#[inline]
pub fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
- self.as_mut_slice().mut_split_at(mid)
+ self.as_mut_slice().split_at_mut(mid)
}
/// Reverses the order of elements in a vector, in place.
fn test_mut_slice_from() {
let mut values = Vec::from_slice([1u8,2,3,4,5]);
{
- let slice = values.mut_slice_from(2);
+ let slice = values.slice_from_mut(2);
assert!(slice == [3, 4, 5]);
- for p in slice.mut_iter() {
+ for p in slice.iter_mut() {
*p += 2;
}
}
fn test_mut_slice_to() {
let mut values = Vec::from_slice([1u8,2,3,4,5]);
{
- let slice = values.mut_slice_to(2);
+ let slice = values.slice_to_mut(2);
assert!(slice == [1, 2]);
- for p in slice.mut_iter() {
+ for p in slice.iter_mut() {
*p += 1;
}
}
fn test_mut_split_at() {
let mut values = Vec::from_slice([1u8,2,3,4,5]);
{
- let (left, right) = values.mut_split_at(2);
+ let (left, right) = values.split_at_mut(2);
assert!(left.slice(0, left.len()) == [1, 2]);
- for p in left.mut_iter() {
+ for p in left.iter_mut() {
*p += 1;
}
assert!(right.slice(0, right.len()) == [3, 4, 5]);
- for p in right.mut_iter() {
+ for p in right.iter_mut() {
*p += 2;
}
}
for &() in v.iter() {}
- assert_eq!(v.mut_iter().count(), 2);
+ assert_eq!(v.iter_mut().count(), 2);
v.push(());
- assert_eq!(v.mut_iter().count(), 3);
+ assert_eq!(v.iter_mut().count(), 3);
v.push(());
- assert_eq!(v.mut_iter().count(), 4);
+ assert_eq!(v.iter_mut().count(), 4);
- for &() in v.mut_iter() {}
+ for &() in v.iter_mut() {}
unsafe { v.set_len(0); }
- assert_eq!(v.mut_iter().count(), 0);
+ assert_eq!(v.iter_mut().count(), 0);
}
#[test]
vec.push(1);
vec.push(2);
let ptr = vec.as_ptr();
- vec = vec.move_iter().unwrap();
+ vec = vec.into_iter().unwrap();
assert_eq!(vec.as_ptr(), ptr);
assert_eq!(vec.capacity(), 7);
assert_eq!(vec.len(), 0);
b.bytes = src_len as u64;
b.iter(|| {
- let dst: Vec<uint> = FromIterator::from_iter(src.clone().move_iter());
+ let dst: Vec<uint> = FromIterator::from_iter(src.clone().into_iter());
assert_eq!(dst.len(), src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
b.iter(|| {
let mut dst = dst.clone();
- dst.extend(src.clone().move_iter());
+ dst.extend(src.clone().into_iter());
assert_eq!(dst.len(), dst_len + src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
_ => ()
}
- buf.mut_slice_to(end).reverse();
+ buf.slice_to_mut(end).reverse();
// Remember start of the fractional digits.
// Points one beyond end of buf if none get generated,
impl<'a> fmt::FormatWriter for Filler<'a> {
fn write(&mut self, bytes: &[u8]) -> fmt::Result {
- slice::bytes::copy_memory(self.buf.mut_slice_from(*self.end),
+ slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end),
bytes);
*self.end += bytes.len();
Ok(())
// Writes the sign if it exists, and then the prefix if it was requested
let write_prefix = |f: &mut Formatter| {
- for c in sign.move_iter() {
+ for c in sign.into_iter() {
let mut b = [0, ..4];
let n = c.encode_utf8(b).unwrap_or(0);
try!(f.buf.write(b.slice_to(n)));
if is_positive {
// Accumulate each digit of the number from the least significant
// to the most significant figure.
- for byte in buf.mut_iter().rev() {
+ for byte in buf.iter_mut().rev() {
let n = x % base; // Get the current place value.
x = x / base; // Deaccumulate the number.
*byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
}
} else {
// Do the same as above, but accounting for two's complement.
- for byte in buf.mut_iter().rev() {
+ for byte in buf.iter_mut().rev() {
let n = -(x % base); // Get the current place value.
x = x / base; // Deaccumulate the number.
*byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
/// sum
/// }
/// let x = vec![1i,2,3,7,8,9];
- /// assert_eq!(process(x.move_iter()), 1006);
+ /// assert_eq!(process(x.into_iter()), 1006);
/// ```
#[inline]
fn fuse(self) -> Fuse<Self> {
#[inline]
fn next(&mut self) -> Option<B> {
loop {
- for inner in self.frontiter.mut_iter() {
+ for inner in self.frontiter.iter_mut() {
for x in *inner {
return Some(x)
}
#[inline]
fn next_back(&mut self) -> Option<B> {
loop {
- for inner in self.backiter.mut_iter() {
+ for inner in self.backiter.iter_mut() {
match inner.next_back() {
None => (),
y => return y
/// ```
/// use std::ptr;
///
-/// let p: *mut int = ptr::mut_null();
+/// let p: *mut int = ptr::null_mut();
/// assert!(p.is_null());
/// ```
#[inline]
impl<T> RawPtr<T> for *mut T {
#[inline]
- fn null() -> *mut T { mut_null() }
+ fn null() -> *mut T { null_mut() }
#[inline]
fn is_null(&self) -> bool { *self == RawPtr::null() }
* ```ignore
* if self.len() == 0 { return None; }
* let head = &mut self[0];
- * *self = self.mut_slice_from(1);
+ * *self = self.slice_from_mut(1);
* Some(head)
* ```
*
* ```ignore
* if self.len() == 0 { return None; }
* let tail = &mut self[self.len() - 1];
- * *self = self.mut_slice_to(self.len() - 1);
+ * *self = self.slice_to_mut(self.len() - 1);
* Some(tail)
* ```
*
///
/// // scoped to restrict the lifetime of the borrows
/// {
- /// let (left, right) = v.mut_split_at(0);
+ /// let (left, right) = v.split_at_mut(0);
/// assert!(left == &mut []);
/// assert!(right == &mut [1i, 2, 3, 4, 5, 6]);
/// }
///
/// {
- /// let (left, right) = v.mut_split_at(2);
+ /// let (left, right) = v.split_at_mut(2);
/// assert!(left == &mut [1i, 2]);
/// assert!(right == &mut [3i, 4, 5, 6]);
/// }
///
/// {
- /// let (left, right) = v.mut_split_at(6);
+ /// let (left, right) = v.split_at_mut(6);
/// assert!(left == &mut [1i, 2, 3, 4, 5, 6]);
/// assert!(right == &mut []);
/// }
#[inline]
fn slice_from_mut(self, start: uint) -> &'a mut [T] {
let len = self.len();
- self.mut_slice(start, len)
+ self.slice_mut(start, len)
}
#[inline]
fn slice_to_mut(self, end: uint) -> &'a mut [T] {
- self.mut_slice(0, end)
+ self.slice_mut(0, end)
}
#[inline]
unsafe {
let len = self.len();
let self2: &'a mut [T] = mem::transmute_copy(&self);
- (self.mut_slice(0, mid), self2.mut_slice(mid, len))
+ (self.slice_mut(0, mid), self2.slice_mut(mid, len))
}
}
while i < ln / 2 {
// Unsafe swap to avoid the bounds check in safe swap.
unsafe {
- let pa: *mut T = self.unsafe_mut_ref(i);
- let pb: *mut T = self.unsafe_mut_ref(ln - i - 1);
+ let pa: *mut T = self.unsafe_mut(i);
+ let pb: *mut T = self.unsafe_mut(ln - i - 1);
ptr::swap(pa, pb);
}
i += 1;
#[inline]
unsafe fn unsafe_set(self, index: uint, val: T) {
- *self.unsafe_mut_ref(index) = val;
+ *self.unsafe_mut(index) = val;
}
#[inline]
impl<'a, T:Clone> MutableCloneableSlice<T> for &'a mut [T] {
#[inline]
fn clone_from_slice(self, src: &[T]) -> uint {
- for (a, b) in self.mut_iter().zip(src.iter()) {
+ for (a, b) in self.iter_mut().zip(src.iter()) {
a.clone_from(b);
}
cmp::min(self.len(), src.len())
self.finished = true;
let tmp = mem::replace(&mut self.v, &mut []);
let len = tmp.len();
- let (head, tail) = tmp.mut_split_at(len);
+ let (head, tail) = tmp.split_at_mut(len);
self.v = tail;
Some(head)
}
Some(idx) => {
let tmp = mem::replace(&mut self.v, &mut []);
- let (head, tail) = tmp.mut_split_at(idx);
- self.v = tail.mut_slice_from(1);
+ let (head, tail) = tmp.split_at_mut(idx);
+ self.v = tail.slice_from_mut(1);
Some(head)
}
}
}
Some(idx) => {
let tmp = mem::replace(&mut self.v, &mut []);
- let (head, tail) = tmp.mut_split_at(idx);
+ let (head, tail) = tmp.split_at_mut(idx);
self.v = head;
- Some(tail.mut_slice_from(1))
+ Some(tail.slice_from_mut(1))
}
}
}
} else {
let sz = cmp::min(self.v.len(), self.chunk_size);
let tmp = mem::replace(&mut self.v, &mut []);
- let (head, tail) = tmp.mut_split_at(sz);
+ let (head, tail) = tmp.split_at_mut(sz);
self.v = tail;
Some(head)
}
let sz = if remainder != 0 { remainder } else { self.chunk_size };
let tmp = mem::replace(&mut self.v, &mut []);
let tmp_len = tmp.len();
- let (head, tail) = tmp.mut_split_at(tmp_len - sz);
+ let (head, tail) = tmp.split_at_mut(tmp_len - sz);
self.v = head;
Some(tail)
}
#[test]
fn test_reverse() {
let mut ys = [1i, 2, 3, 4, 5];
- ys.mut_iter().reverse_();
+ ys.iter_mut().reverse_();
assert!(ys == [5, 4, 3, 2, 1]);
}
let mut x = Some(val);
{
- let mut it = x.mut_iter();
+ let mut it = x.iter_mut();
assert_eq!(it.size_hint(), (1, Some(1)));
// test that it does not take more elements than it needs
let mut functions = [|| Some(()), || None, || fail!()];
- let v: Option<Vec<()>> = collect(functions.mut_iter().map(|f| (*f)()));
+ let v: Option<Vec<()>> = collect(functions.iter_mut().map(|f| (*f)()));
assert!(v == None);
}
// test that it does not take more elements than it needs
let mut functions = [|| Ok(()), || Err(1i), || fail!()];
- let v: Result<Vec<()>, int> = collect(functions.mut_iter().map(|f| (*f)()));
+ let v: Result<Vec<()>, int> = collect(functions.iter_mut().map(|f| (*f)()));
assert!(v == Err(1));
}
// test that it does not take more elements than it needs
let mut functions = [|| Ok(()), || Err(1i), || fail!()];
- assert_eq!(fold_(functions.mut_iter()
+ assert_eq!(fold_(functions.iter_mut()
.map(|f| (*f)())),
Err(1));
}
match fs::readdir(path) {
Ok(mut children) => {
children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename()));
- Some(children.move_iter().collect())
+ Some(children.into_iter().collect())
}
Err(..) => None
}
None => {
match list_dir_sorted(path) {
Some(entries) => {
- todo.extend(entries.move_iter().map(|x|(x, idx)));
+ todo.extend(entries.into_iter().map(|x|(x, idx)));
// Matching the special directory entries . and .. that refer to
// the current and parent directory respectively requires that
fn to_opt_strs(self) -> Vec<Option<&'static str>> {
match self {
UnlabelledNodes(len)
- => Vec::from_elem(len, None).move_iter().collect(),
+ => Vec::from_elem(len, None).into_iter().collect(),
AllNodesLabelled(lbls)
- => lbls.move_iter().map(
+ => lbls.into_iter().map(
|l|Some(l)).collect(),
SomeNodesLabelled(lbls)
- => lbls.move_iter().collect(),
+ => lbls.into_iter().collect(),
}
}
}
/// Process everything in the work queue (continually)
fn work(&mut self) {
while self.work.len() > 0 {
- for work in mem::replace(&mut self.work, vec![]).move_iter() {
+ for work in mem::replace(&mut self.work, vec![]).into_iter() {
work();
}
}
let messages = unsafe {
mem::replace(&mut *self.messages.lock(), Vec::new())
};
- for message in messages.move_iter() {
+ for message in messages.into_iter() {
self.message(message);
}
}
fn message(&mut self, message: Message) {
match message {
RunRemote(i) => {
- match self.remotes.mut_iter().find(|& &(id, _)| id == i) {
+ match self.remotes.iter_mut().find(|& &(id, _)| id == i) {
Some(&(_, ref mut f)) => f.call(),
None => unreachable!()
}
// Now that we've got all our work queues, create one scheduler per
// queue, spawn the scheduler into a thread, and be sure to keep a
// handle to the scheduler and the thread to keep them alive.
- for worker in workers.move_iter() {
+ for worker in workers.into_iter() {
rtdebug!("inserting a regular scheduler");
let mut sched = box Scheduler::new(pool.id,
// Tell all existing schedulers about this new scheduler so they can all
// steal work from it
- for handle in self.handles.mut_iter() {
+ for handle in self.handles.iter_mut() {
handle.send(NewNeighbor(stealer.clone()));
}
}
// Now that everyone's gone, tell everything to shut down.
- for mut handle in replace(&mut self.handles, vec![]).move_iter() {
+ for mut handle in replace(&mut self.handles, vec![]).into_iter() {
handle.send(Shutdown);
}
- for thread in replace(&mut self.threads, vec![]).move_iter() {
+ for thread in replace(&mut self.threads, vec![]).into_iter() {
thread.join();
}
}
let root = unsafe { CString::new(root.as_ptr(), false) };
let root = Path::new(root);
- dirs.move_iter().filter(|path| {
+ dirs.into_iter().filter(|path| {
path.as_vec() != b"." && path.as_vec() != b".."
}).map(|path| root.join(path).to_c_str()).collect()
}
let ret = unsafe {
libc::ReadFile(self.handle(), buf.as_ptr() as libc::LPVOID,
buf.len() as libc::DWORD, &mut read,
- ptr::mut_null())
+ ptr::null_mut())
};
if ret != 0 {
Ok(read as uint)
let ret = unsafe {
libc::WriteFile(self.handle(), cur as libc::LPVOID,
remaining as libc::DWORD, &mut amt,
- ptr::mut_null())
+ ptr::null_mut())
};
if ret != 0 {
remaining -= amt as uint;
libc::CreateFileW(path.as_ptr(),
dwDesiredAccess,
dwShareMode,
- ptr::mut_null(),
+ ptr::null_mut(),
dwCreationDisposition,
dwFlagsAndAttributes,
- ptr::mut_null())
+ ptr::null_mut())
};
if handle == libc::INVALID_HANDLE_VALUE {
Err(super::last_error())
let p = try!(to_utf16(p));
super::mkerr_winbool(unsafe {
// FIXME: turn mode into something useful? #2623
- libc::CreateDirectoryW(p.as_ptr(), ptr::mut_null())
+ libc::CreateDirectoryW(p.as_ptr(), ptr::null_mut())
})
}
let root = unsafe { CString::new(root.as_ptr(), false) };
let root = Path::new(root);
- dirs.move_iter().filter(|path| {
+ dirs.into_iter().filter(|path| {
path.as_vec() != b"." && path.as_vec() != b".."
}).map(|path| root.join(path).to_c_str()).collect()
}
libc::CreateFileW(p.as_ptr(),
libc::GENERIC_READ,
libc::FILE_SHARE_READ,
- ptr::mut_null(),
+ ptr::null_mut(),
libc::OPEN_EXISTING,
libc::FILE_ATTRIBUTE_NORMAL,
- ptr::mut_null())
+ ptr::null_mut())
};
if handle == libc::INVALID_HANDLE_VALUE {
return Err(super::last_error())
let src = try!(to_utf16(src));
let dst = try!(to_utf16(dst));
super::mkerr_winbool(unsafe {
- libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::mut_null())
+ libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut())
})
}
pub fn new() -> (HANDLE, HANDLE) {
unsafe {
- let handle = CreateEventA(ptr::mut_null(), libc::FALSE, libc::FALSE,
+ let handle = CreateEventA(ptr::null_mut(), libc::FALSE, libc::FALSE,
ptr::null());
(handle, handle)
}
Vec<Option<Box<rtio::RtioPipe + Send>>>)> {
process::Process::spawn(cfg).map(|(p, io)| {
(box p as Box<rtio::RtioProcess + Send>,
- io.move_iter().map(|p| p.map(|p| {
+ io.into_iter().map(|p| p.map(|p| {
box p as Box<rtio::RtioPipe + Send>
})).collect())
})
while !self.inner.closed.load(atomic::SeqCst) {
match retry(|| unsafe {
- libc::accept(self.fd(), ptr::mut_null(), ptr::mut_null())
+ libc::accept(self.fd(), ptr::null_mut(), ptr::null_mut())
}) {
-1 if util::wouldblock() => {}
-1 => return Err(os::last_error()),
if wsaevents.lNetworkEvents & c::FD_ACCEPT == 0 { continue }
match unsafe {
- libc::accept(self.fd(), ptr::mut_null(), ptr::mut_null())
+ libc::accept(self.fd(), ptr::null_mut(), ptr::null_mut())
} {
-1 if util::wouldblock() => {}
-1 => return Err(os::last_error()),
})
}
s.sun_family = libc::AF_UNIX as libc::sa_family_t;
- for (slot, value) in s.sun_path.mut_iter().zip(addr.iter()) {
+ for (slot, value) in s.sun_path.iter_mut().zip(addr.iter()) {
*slot = value;
}
impl Event {
fn new(manual_reset: bool, initial_state: bool) -> IoResult<Event> {
let event = unsafe {
- libc::CreateEventW(ptr::mut_null(),
+ libc::CreateEventW(ptr::null_mut(),
manual_reset as libc::BOOL,
initial_state as libc::BOOL,
ptr::null())
65536,
65536,
0,
- ptr::mut_null()
+ ptr::null_mut()
)
}
libc::CreateFileW(p,
libc::GENERIC_READ | libc::GENERIC_WRITE,
0,
- ptr::mut_null(),
+ ptr::null_mut(),
libc::OPEN_EXISTING,
libc::FILE_FLAG_OVERLAPPED,
- ptr::mut_null())
+ ptr::null_mut())
};
if result != libc::INVALID_HANDLE_VALUE {
return Some(result)
libc::CreateFileW(p,
libc::GENERIC_READ | libc::FILE_WRITE_ATTRIBUTES,
0,
- ptr::mut_null(),
+ ptr::null_mut(),
libc::OPEN_EXISTING,
libc::FILE_FLAG_OVERLAPPED,
- ptr::mut_null())
+ ptr::null_mut())
};
if result != libc::INVALID_HANDLE_VALUE {
return Some(result)
libc::CreateFileW(p,
libc::GENERIC_WRITE | libc::FILE_READ_ATTRIBUTES,
0,
- ptr::mut_null(),
+ ptr::null_mut(),
libc::OPEN_EXISTING,
libc::FILE_FLAG_OVERLAPPED,
- ptr::mut_null())
+ ptr::null_mut())
};
if result != libc::INVALID_HANDLE_VALUE {
return Some(result)
let ret = unsafe {
libc::SetNamedPipeHandleState(inner.handle,
&mut mode,
- ptr::mut_null(),
- ptr::mut_null())
+ ptr::null_mut(),
+ ptr::null_mut())
};
return if ret == 0 {
Err(super::last_error())
}
fn cancel_io(&self) -> IoResult<()> {
- match unsafe { c::CancelIoEx(self.handle(), ptr::mut_null()) } {
+ match unsafe { c::CancelIoEx(self.handle(), ptr::null_mut()) } {
0 if os::errno() == libc::ERROR_NOT_FOUND as uint => {
Ok(())
}
if b"PATH" != key.as_bytes_no_nul() { continue }
// Split the value and test each path to see if the program exists.
- for path in os::split_paths(v.as_bytes_no_nul()).move_iter() {
+ for path in os::split_paths(v.as_bytes_no_nul()).into_iter() {
let path = path.join(cfg.program.as_bytes_no_nul())
.with_extension(os::consts::EXE_EXTENSION);
if path.exists() {
let size = mem::size_of::<libc::SECURITY_ATTRIBUTES>();
let mut sa = libc::SECURITY_ATTRIBUTES {
nLength: size as libc::DWORD,
- lpSecurityDescriptor: ptr::mut_null(),
+ lpSecurityDescriptor: ptr::null_mut(),
bInheritHandle: 1,
};
let filename: Vec<u16> = "NUL".utf16_units().collect();
&mut sa,
libc::OPEN_EXISTING,
0,
- ptr::mut_null());
+ ptr::null_mut());
if *slot == INVALID_HANDLE_VALUE {
return Err(super::last_error())
}
cmd_str = cmd_str.append_one(0);
let created = CreateProcessW(ptr::null(),
cmd_str.as_mut_ptr(),
- ptr::mut_null(),
- ptr::mut_null(),
+ ptr::null_mut(),
+ ptr::null_mut(),
TRUE,
flags, envp, dirp,
&mut si, &mut pi);
fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
libc::types::os::arch::extra::STARTUPINFO {
cb: 0,
- lpReserved: ptr::mut_null(),
- lpDesktop: ptr::mut_null(),
- lpTitle: ptr::mut_null(),
+ lpReserved: ptr::null_mut(),
+ lpDesktop: ptr::null_mut(),
+ lpTitle: ptr::null_mut(),
dwX: 0,
dwY: 0,
dwXSize: 0,
dwFlags: 0,
wShowWindow: 0,
cbReserved2: 0,
- lpReserved2: ptr::mut_null(),
+ lpReserved2: ptr::null_mut(),
hStdInput: libc::INVALID_HANDLE_VALUE,
hStdOutput: libc::INVALID_HANDLE_VALUE,
hStdError: libc::INVALID_HANDLE_VALUE,
#[cfg(windows)]
fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION {
libc::types::os::arch::extra::PROCESS_INFORMATION {
- hProcess: ptr::mut_null(),
- hThread: ptr::mut_null(),
+ hProcess: ptr::null_mut(),
+ hThread: ptr::null_mut(),
dwProcessId: 0,
dwThreadId: 0
}
Err(..) => {
Ok(SpawnProcessResult {
pid: pid,
- handle: ptr::mut_null()
+ handle: ptr::null_mut()
})
}
Ok(..) => fail!("short read on the cloexec pipe"),
cb(blk.as_mut_ptr() as *mut c_void)
}
- _ => cb(ptr::mut_null())
+ _ => cb(ptr::null_mut())
}
}
tv = util::ms_to_timeval(ms);
(&mut tv as *mut _, idx)
}
- None => (ptr::mut_null(), -1),
+ None => (ptr::null_mut(), -1),
};
// Wait for something to happen
c::fd_set(&mut set, input);
c::fd_set(&mut set, read_fd);
- match unsafe { c::select(max, &mut set, ptr::mut_null(),
- ptr::mut_null(), p) } {
+ match unsafe { c::select(max, &mut set, ptr::null_mut(),
+ ptr::null_mut(), p) } {
// interrupted, retry
-1 if os::errno() == libc::EINTR as int => continue,
// Once this helper thread is done, we re-register the old sigchld
// handler and close our intermediate file descriptors.
unsafe {
- assert_eq!(c::sigaction(c::SIGCHLD, &old, ptr::mut_null()), 0);
+ assert_eq!(c::sigaction(c::SIGCHLD, &old, ptr::null_mut()), 0);
let _ = libc::close(read_fd);
let _ = libc::close(WRITE_FD);
WRITE_FD = -1;
pub fn now() -> u64 {
unsafe {
let mut now: libc::timeval = mem::zeroed();
- assert_eq!(c::gettimeofday(&mut now, ptr::mut_null()), 0);
+ assert_eq!(c::gettimeofday(&mut now, ptr::null_mut()), 0);
return (now.tv_sec as u64) * 1000 + (now.tv_usec as u64) / 1000;
}
}
'outer: loop {
let timeout = if active.len() == 0 {
// Empty array? no timeout (wait forever for the next request)
- ptr::mut_null()
+ ptr::null_mut()
} else {
let now = now();
// If this request has already expired, then signal it and go
c::fd_set(&mut set, input);
match unsafe {
- c::select(input + 1, &mut set, ptr::mut_null(),
- ptr::mut_null(), timeout)
+ c::select(input + 1, &mut set, ptr::null_mut(),
+ ptr::null_mut(), timeout)
} {
// timed out
0 => signal(&mut active, &mut dead),
unsafe { HELPER.boot(|| {}, helper) }
let obj = unsafe {
- imp::CreateWaitableTimerA(ptr::mut_null(), 0, ptr::null())
+ imp::CreateWaitableTimerA(ptr::null_mut(), 0, ptr::null())
};
if obj.is_null() {
Err(super::last_error())
// 100ns intervals, so we multiply by 10^4.
let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
assert_eq!(unsafe {
- imp::SetWaitableTimer(self.obj, &due, 0, ptr::mut_null(),
- ptr::mut_null(), 0)
+ imp::SetWaitableTimer(self.obj, &due, 0, ptr::null_mut(),
+ ptr::null_mut(), 0)
}, 1);
let _ = unsafe { imp::WaitForSingleObject(self.obj, libc::INFINITE) };
// see above for the calculation
let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
assert_eq!(unsafe {
- imp::SetWaitableTimer(self.obj, &due, 0, ptr::mut_null(),
- ptr::mut_null(), 0)
+ imp::SetWaitableTimer(self.obj, &due, 0, ptr::null_mut(),
+ ptr::null_mut(), 0)
}, 1);
unsafe { HELPER.send(NewTimer(self.obj, cb, true)) }
let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
assert_eq!(unsafe {
imp::SetWaitableTimer(self.obj, &due, msecs as libc::LONG,
- ptr::mut_null(), ptr::mut_null(), 0)
+ ptr::null_mut(), ptr::null_mut(), 0)
}, 1);
unsafe { HELPER.send(NewTimer(self.obj, cb, false)) }
utf16.as_mut_ptr() as LPVOID,
utf16.len() as u32,
&mut num as LPDWORD,
- ptr::mut_null()) } {
+ ptr::null_mut()) } {
0 => return Err(super::last_error()),
_ => (),
};
utf16.as_ptr() as LPCVOID,
utf16.len() as u32,
&mut num as LPDWORD,
- ptr::mut_null()) } {
+ ptr::null_mut()) } {
0 => Err(super::last_error()),
_ => Ok(()),
}
// undefined what the value of the 'tv' is after select
// returns EINTR).
let mut tv = ms_to_timeval(timeout - (::io::timer::now() - start));
- c::select(fd + 1, ptr::mut_null(), set as *mut _,
- ptr::mut_null(), &mut tv)
+ c::select(fd + 1, ptr::null_mut(), set as *mut _,
+ ptr::null_mut(), &mut tv)
})
}
#[cfg(windows)]
fn await(_fd: net::sock_t, set: &mut c::fd_set,
timeout: u64) -> libc::c_int {
let mut tv = ms_to_timeval(timeout);
- unsafe { c::select(1, ptr::mut_null(), set, ptr::mut_null(), &mut tv) }
+ unsafe { c::select(1, ptr::null_mut(), set, ptr::null_mut(), &mut tv) }
}
}
}
let (read, write) = match status {
- Readable => (&mut set as *mut _, ptr::mut_null()),
- Writable => (ptr::mut_null(), &mut set as *mut _),
+ Readable => (&mut set as *mut _, ptr::null_mut()),
+ Writable => (ptr::null_mut(), &mut set as *mut _),
};
let mut tv: libc::timeval = unsafe { mem::zeroed() };
match retry(|| {
let now = ::io::timer::now();
let tvp = match deadline {
- None => ptr::mut_null(),
+ None => ptr::null_mut(),
Some(deadline) => {
// If we're past the deadline, then pass a 0 timeout to
// select() so we can poll the status
}
};
let r = unsafe {
- c::select(max as libc::c_int, read, write, ptr::mut_null(), tvp)
+ c::select(max as libc::c_int, read, write, ptr::null_mut(), tvp)
};
r
}) {
// we convert the list from individual weights to cumulative
// weights so we can binary search. This *could* drop elements
// with weight == 0 as an optimisation.
- for item in items.mut_iter() {
+ for item in items.iter_mut() {
running_total = match running_total.checked_add(&item.weight) {
Some(n) => n,
None => fail!("WeightedChoice::new called with a total weight \
// - 1], 0, 0, ...], to fill rng.rsl.
let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u32));
- for (rsl_elem, seed_elem) in self.rsl.mut_iter().zip(seed_iter) {
+ for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
*rsl_elem = seed_elem;
}
self.cnt = 0;
// - 1], 0, 0, ...], to fill rng.rsl.
let seed_iter = seed.iter().map(|&x| x).chain(Repeat::new(0u64));
- for (rsl_elem, seed_elem) in self.rsl.mut_iter().zip(seed_iter) {
+ for (rsl_elem, seed_elem) in self.rsl.iter_mut().zip(seed_iter) {
*rsl_elem = seed_elem;
}
self.cnt = 0;
// optimisations are on.
let mut count = 0i;
let mut num = 0;
- for byte in dest.mut_iter() {
+ for byte in dest.iter_mut() {
if count == 0 {
// we could micro-optimise here by generating a u32 if
// we only need a few more bytes to fill the vector
// Do the necessary writes
if left.len() > 0 {
- slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left);
+ slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), left);
}
if right.len() > 0 {
self.buf.push_all(right);
self.push(Save(2 * cap + 1));
}
Cat(xs) => {
- for x in xs.move_iter() {
+ for x in xs.into_iter() {
self.compile(x)
}
}
if ranges.len() > 0 {
let flags = negated | (self.flags & FLAG_NOCASE);
let mut ast = Class(combine_ranges(ranges), flags);
- for alt in alts.move_iter() {
+ for alt in alts.into_iter() {
ast = Alt(box alt, box ast)
}
self.push(ast);
} else if alts.len() > 0 {
let mut ast = alts.pop().unwrap();
- for alt in alts.move_iter() {
+ for alt in alts.into_iter() {
ast = Alt(box alt, box ast)
}
self.push(ast);
// This is currently O(n^2), but I think with sufficient cleverness,
// it can be reduced to O(n) **if necessary**.
let mut ordered: Vec<(char, char)> = Vec::with_capacity(unordered.len());
- for (us, ue) in unordered.move_iter() {
+ for (us, ue) in unordered.into_iter() {
let (mut us, mut ue) = (us, ue);
assert!(us <= ue);
let mut which: Option<uint> = None;
let mut rng = task_rng();
let mut bytes = rng.gen_ascii_chars().map(|n| n as u8).take(n)
.collect::<Vec<u8>>();
- for (i, b) in bytes.mut_iter().enumerate() {
+ for (i, b) in bytes.iter_mut().enumerate() {
if i % 20 == 0 {
*b = b'\n'
}
return StepMatch
}
Submatches => {
- for (slot, val) in groups.mut_iter().zip(caps.iter()) {
+ for (slot, val) in groups.iter_mut().zip(caps.iter()) {
*slot = *val;
}
return StepMatch
*t.groups.get_mut(1) = groups[1];
}
(false, Submatches) => {
- for (slot, val) in t.groups.mut_iter().zip(groups.iter()) {
+ for (slot, val) in t.groups.iter_mut().zip(groups.iter()) {
*slot = *val;
}
}
t.groups[1] = groups[1];
}
Submatches => {
- for (slot, val) in t.groups.mut_iter().zip(groups.iter()) {
+ for (slot, val) in t.groups.iter_mut().zip(groups.iter()) {
*slot = *val;
}
}
return StepMatch
}
Submatches => {
- for (slot, val) in groups.mut_iter().zip(caps.iter()) {
+ for (slot, val) in groups.iter_mut().zip(caps.iter()) {
*slot = *val;
}
return StepMatch
}
pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String {
- mangle(path.chain(Some(gensym_name(flav)).move_iter()), None)
+ mangle(path.chain(Some(gensym_name(flav)).into_iter()), None)
}
pub fn get_cc_prog(sess: &Session) -> String {
ab.add_rlib(&p, name.as_slice(), sess.lto()).unwrap();
let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
- all_native_libs.extend(native_libs.move_iter());
+ all_native_libs.extend(native_libs.into_iter());
}
ab.update_symbols();
// we're just getting an ordering of crate numbers, we're not worried about
// the paths.
let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
- for (cnum, _) in crates.move_iter() {
+ for (cnum, _) in crates.into_iter() {
let libs = csearch::get_native_libraries(&sess.cstore, cnum);
for &(kind, ref lib) in libs.iter() {
match kind {
// load the bitcode from the archive. Then merge it into the current LLVM
// module that we've got.
let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
- for (cnum, path) in crates.move_iter() {
+ for (cnum, path) in crates.into_iter() {
let name = sess.cstore.get_crate_data(cnum).name.clone();
let path = match path {
Some(p) => p,
}
let mut failed = false;
- for future in futures.move_iter() {
+ for future in futures.into_iter() {
match future.unwrap() {
Ok(()) => {},
Err(_) => {
pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions
{
let mut cg = basic_codegen_options();
- for option in matches.opt_strs("C").move_iter() {
+ for option in matches.opt_strs("C").into_iter() {
let mut iter = option.as_slice().splitn(1, '=');
let key = iter.next().unwrap();
let value = iter.next();
if sess.opts.test {
append_configuration(&mut user_cfg, InternedString::new("test"))
}
- user_cfg.move_iter().collect::<Vec<_>>().append(default_cfg.as_slice())
+ user_cfg.into_iter().collect::<Vec<_>>().append(default_cfg.as_slice())
}
pub fn get_os(triple: &str) -> Option<abi::Os> {
// Convert strings provided as --cfg [cfgspec] into a crate_cfg
fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig {
- cfgspecs.move_iter().map(|s| {
+ cfgspecs.into_iter().map(|s| {
parse::parse_meta_from_source_str("cfgspec".to_string(),
s.to_string(),
Vec::new(),
let mut describe_lints = false;
for &level in [lint::Allow, lint::Warn, lint::Deny, lint::Forbid].iter() {
- for lint_name in matches.opt_strs(level.as_str()).move_iter() {
+ for lint_name in matches.opt_strs(level.as_str()).into_iter() {
if lint_name.as_slice() == "help" {
describe_lints = true;
} else {
{
let mut ls = sess.lint_store.borrow_mut();
- for pass in lint_passes.move_iter() {
+ for pass in lint_passes.into_iter() {
ls.register_pass(Some(sess), true, pass);
}
- for (name, to) in lint_groups.move_iter() {
+ for (name, to) in lint_groups.into_iter() {
ls.register_group(Some(sess), true, name, to);
}
}
// will be found in crate attributes.
let mut base = session.opts.crate_types.clone();
if base.len() == 0 {
- base.extend(attr_types.move_iter());
+ base.extend(attr_types.into_iter());
if base.len() == 0 {
base.push(link::default_output_for_target(session));
}
base.dedup();
}
- base.move_iter().filter(|crate_type| {
+ base.into_iter().filter(|crate_type| {
let res = !link::invalid_output_for_target(session, *crate_type);
if !res {
");
fn sort_lints(lints: Vec<(&'static Lint, bool)>) -> Vec<&'static Lint> {
- let mut lints: Vec<_> = lints.move_iter().map(|(x, _)| x).collect();
+ let mut lints: Vec<_> = lints.into_iter().map(|(x, _)| x).collect();
lints.sort_by(|x: &&Lint, y: &&Lint| {
match x.default_level.cmp(&y.default_level) {
// The sort doesn't case-fold but it's doubtful we care.
fn sort_lint_groups(lints: Vec<(&'static str, Vec<lint::LintId>, bool)>)
-> Vec<(&'static str, Vec<lint::LintId>)> {
- let mut lints: Vec<_> = lints.move_iter().map(|(x, y, _)| (x, y)).collect();
+ let mut lints: Vec<_> = lints.into_iter().map(|(x, y, _)| (x, y)).collect();
lints.sort_by(|&(x, _): &(&'static str, Vec<lint::LintId>),
&(y, _): &(&'static str, Vec<lint::LintId>)| {
x.cmp(&y)
println!(" {} {:7.7s} {}", padded("----"), "-------", "-------");
let print_lints = |lints: Vec<&Lint>| {
- for lint in lints.move_iter() {
+ for lint in lints.into_iter() {
let name = lint.name_lower().replace("_", "-");
println!(" {} {:7.7s} {}",
padded(name.as_slice()), lint.default_level.as_str(), lint.desc);
println!(" {} {}", padded("----"), "---------");
let print_lint_groups = |lints: Vec<(&'static str, Vec<lint::LintId>)>| {
- for (name, to) in lints.move_iter() {
+ for (name, to) in lints.into_iter() {
let name = name.chars().map(|x| x.to_lowercase())
.collect::<String>().replace("_", "-");
- let desc = to.move_iter().map(|x| x.as_str()).collect::<Vec<String>>().connect(", ");
+ let desc = to.into_iter().map(|x| x.as_str()).collect::<Vec<String>>().connect(", ");
println!(" {} {}",
padded(name.as_slice()), desc);
}
&sess.parse_sess)
}
};
- result.move_iter().collect()
+ result.into_iter().collect()
}
pub fn early_error(msg: &str) -> ! {
-> NodesMatchingUII<'a, 'ast> {
match *self {
ItemViaNode(node_id) =>
- NodesMatchingDirect(Some(node_id).move_iter()),
+ NodesMatchingDirect(Some(node_id).into_iter()),
ItemViaPath(ref parts) =>
NodesMatchingSuffix(map.nodes_matching_suffix(parts.as_slice())),
}
fn fold_mod(cx: &mut Context, ast::Mod {inner, view_items, items}: ast::Mod) -> ast::Mod {
ast::Mod {
inner: inner,
- view_items: view_items.move_iter().filter_map(|a| {
+ view_items: view_items.into_iter().filter_map(|a| {
filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
}).collect(),
- items: items.move_iter().filter_map(|a| {
+ items: items.into_iter().filter_map(|a| {
if item_in_cfg(cx, &*a) {
Some(cx.fold_item(a))
} else {
None
}
- }).flat_map(|x| x.move_iter()).collect()
+ }).flat_map(|x| x.into_iter()).collect()
}
}
-> ast::ForeignMod {
ast::ForeignMod {
abi: abi,
- view_items: view_items.move_iter().filter_map(|a| {
+ view_items: view_items.into_iter().filter_map(|a| {
filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
}).collect(),
- items: items.move_iter()
+ items: items.into_iter()
.filter_map(|a| filter_foreign_item(cx, a))
.collect()
}
fn fold_item_underscore(cx: &mut Context, item: ast::Item_) -> ast::Item_ {
let item = match item {
ast::ItemImpl(a, b, c, impl_items) => {
- let impl_items = impl_items.move_iter()
+ let impl_items = impl_items.into_iter()
.filter(|ii| impl_item_in_cfg(cx, ii))
.collect();
ast::ItemImpl(a, b, c, impl_items)
}
ast::ItemTrait(a, b, c, methods) => {
- let methods = methods.move_iter()
+ let methods = methods.into_iter()
.filter(|m| trait_method_in_cfg(cx, m))
.collect();
ast::ItemTrait(a, b, c, methods)
ast::ItemStruct(fold_struct(cx, def), generics)
}
ast::ItemEnum(def, generics) => {
- let mut variants = def.variants.move_iter().filter_map(|v| {
+ let mut variants = def.variants.into_iter().filter_map(|v| {
if !(cx.in_cfg)(v.node.attrs.as_slice()) {
None
} else {
fn fold_struct(cx: &mut Context, def: P<ast::StructDef>) -> P<ast::StructDef> {
def.map(|ast::StructDef {fields, ctor_id, super_struct, is_virtual}| {
ast::StructDef {
- fields: fields.move_iter().filter(|m| {
+ fields: fields.into_iter().filter(|m| {
(cx.in_cfg)(m.node.attrs.as_slice())
}).collect(),
ctor_id: ctor_id,
fn fold_block(cx: &mut Context, b: P<ast::Block>) -> P<ast::Block> {
b.map(|ast::Block {id, view_items, stmts, expr, rules, span}| {
let resulting_stmts: Vec<P<ast::Stmt>> =
- stmts.move_iter().filter(|a| retain_stmt(cx, &**a)).collect();
- let resulting_stmts = resulting_stmts.move_iter()
- .flat_map(|stmt| cx.fold_stmt(stmt).move_iter())
+ stmts.into_iter().filter(|a| retain_stmt(cx, &**a)).collect();
+ let resulting_stmts = resulting_stmts.into_iter()
+ .flat_map(|stmt| cx.fold_stmt(stmt).into_iter())
.collect();
- let filtered_view_items = view_items.move_iter().filter_map(|a| {
+ let filtered_view_items = view_items.into_iter().filter_map(|a| {
filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
}).collect();
ast::Block {
id: id,
node: match node {
ast::ExprMatch(m, arms) => {
- ast::ExprMatch(m, arms.move_iter()
+ ast::ExprMatch(m, arms.into_iter()
.filter(|a| (cx.in_cfg)(a.attrs.as_slice()))
.collect())
}
ast::Item {
id: id,
ident: ident,
- attrs: attrs.move_iter().filter_map(|attr| {
+ attrs: attrs.into_iter().filter_map(|attr| {
if !attr.check_name("main") {
Some(attr)
} else {
let mut view_items = Vec::new();
let super_ = token::str_to_ident("super");
- view_items.extend(tests.move_iter().map(|r| {
+ view_items.extend(tests.into_iter().map(|r| {
cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public,
cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
}));
- view_items.extend(tested_submods.move_iter().map(|(r, sym)| {
+ view_items.extend(tested_submods.into_iter().map(|(r, sym)| {
let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path)
}));
ast::Path {
span: DUMMY_SP,
global: false,
- segments: ids.move_iter().map(|identifier| ast::PathSegment {
+ segments: ids.into_iter().map(|identifier| ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
types: OwnedSlice::empty(),
);
}
};
- visible_path.extend(path.move_iter());
+ visible_path.extend(path.into_iter());
let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));
// Move the vector of passes out of `$cx` so that we can
// iterate over it mutably while passing `$cx` to the methods.
let mut passes = $cx.lints.passes.take().unwrap();
- for obj in passes.mut_iter() {
+ for obj in passes.iter_mut() {
obj.$f($cx, $($args),*);
}
$cx.lints.passes = Some(passes);
_ => sess.bug("impossible level in raw_emit_lint"),
}
- for span in note.move_iter() {
+ for span in note.into_iter() {
sess.span_note(span, "lint level defined here");
}
}
// specified closure
let mut pushed = 0u;
- for result in gather_attrs(attrs).move_iter() {
+ for result in gather_attrs(attrs).into_iter() {
let v = match result {
Err(span) => {
self.tcx.sess.span_err(span, "malformed lint attribute");
}
};
- for (lint_id, level, span) in v.move_iter() {
+ for (lint_id, level, span) in v.into_iter() {
let now = self.lints.get_level_source(lint_id).val0();
if now == Forbid && level != Forbid {
let lint_name = lint_id.as_str();
match self.tcx.sess.lints.borrow_mut().pop(&id) {
None => {}
Some(lints) => {
- for (lint_id, span, msg) in lints.move_iter() {
+ for (lint_id, span, msg) in lints.into_iter() {
self.span_lint(lint_id.lint, span, msg.as_slice())
}
}
map.find_or_insert_with(data.name(), |_| Vec::new()).push(cnum);
});
- for (name, dupes) in map.move_iter() {
+ for (name, dupes) in map.into_iter() {
if dupes.len() == 1 { continue }
diag.handler().warn(
format!("using multiple versions of crate `{}`", name).as_slice());
- for dupe in dupes.move_iter() {
+ for dupe in dupes.into_iter() {
let data = cstore.get_crate_data(dupe);
diag.span_note(data.span, "used here");
loader::note_crate_name(diag, data.name().as_slice());
let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
let n = token::intern_and_get_ident(nd.as_str_slice());
let subitems = get_meta_items(meta_item_doc);
- items.push(attr::mk_list_item(n, subitems.move_iter().collect()));
+ items.push(attr::mk_list_item(n, subitems.into_iter().collect()));
true
});
return items;
// Currently it's only possible to have a single meta item on
// an attribute
assert_eq!(meta_items.len(), 1u);
- let meta_item = meta_items.move_iter().nth(0).unwrap();
+ let meta_item = meta_items.into_iter().nth(0).unwrap();
attrs.push(
codemap::Spanned {
node: ast::Attribute_ {
encode_bounds_and_type(rbml_w, ecx, &pty);
let elem = ast_map::PathName(m.ident.name);
- encode_path(rbml_w, impl_path.chain(Some(elem).move_iter()));
+ encode_path(rbml_w, impl_path.chain(Some(elem).into_iter()));
match ast_item_opt {
Some(&ast::MethodImplItem(ref ast_method)) => {
encode_attributes(rbml_w, ast_method.attrs.as_slice());
let elem = ast_map::PathName(method_ty.ident.name);
encode_path(rbml_w,
- path.clone().chain(Some(elem).move_iter()));
+ path.clone().chain(Some(elem).into_iter()));
match method_ty.explicit_self {
ty::StaticExplicitSelfCategory => {
fn encode_index<T: Hash>(rbml_w: &mut Encoder, index: Vec<entry<T>>,
write_fn: |&mut SeekableMemWriter, &T|) {
let mut buckets: Vec<Vec<entry<T>>> = Vec::from_fn(256, |_| Vec::new());
- for elt in index.move_iter() {
+ for elt in index.into_iter() {
let h = hash::hash(&elt.val) as uint;
buckets.get_mut(h % 256).push(elt);
}
pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> {
let mut wr = SeekableMemWriter::new();
encode_metadata_inner(&mut wr, parms, krate);
- wr.unwrap().move_iter().collect()
+ wr.unwrap().into_iter().collect()
}
fn encode_metadata_inner(wr: &mut SeekableMemWriter, parms: EncodeParams, krate: &Crate) {
// libraries corresponds to the crate id and hash criteria that this
// search is being performed for.
let mut libraries = Vec::new();
- for (_hash, (rlibs, dylibs)) in candidates.move_iter() {
+ for (_hash, (rlibs, dylibs)) in candidates.into_iter() {
let mut metadata = None;
let rlib = self.extract_one(rlibs, "rlib", &mut metadata);
let dylib = self.extract_one(dylibs, "dylib", &mut metadata);
// libraries or not.
match libraries.len() {
0 => None,
- 1 => Some(libraries.move_iter().next().unwrap()),
+ 1 => Some(libraries.into_iter().next().unwrap()),
_ => {
self.sess.span_err(self.span,
format!("multiple matching crates for `{}`",
if m.len() == 0 {
return None
} else if m.len() == 1 {
- return Some(m.move_iter().next().unwrap())
+ return Some(m.into_iter().next().unwrap())
}
}
- for lib in m.move_iter() {
+ for lib in m.into_iter() {
info!("{} reading metadata from: {}", flavor, lib.display());
let metadata = match get_metadata_section(self.os, &lib) {
Ok(blob) => {
impl Folder for NestedItemsDropper {
fn fold_block(&mut self, blk: P<ast::Block>) -> P<ast::Block> {
blk.and_then(|ast::Block {id, stmts, expr, rules, span, ..}| {
- let stmts_sans_items = stmts.move_iter().filter_map(|stmt| {
+ let stmts_sans_items = stmts.into_iter().filter_map(|stmt| {
let use_stmt = match stmt.node {
ast::StmtExpr(_, _) | ast::StmtSemi(_, _) => true,
ast::StmtDecl(ref decl, _) => {
tcx: &ty::ctxt, cdata: &cstore::crate_metadata)
-> typeck::vtable_param_res {
self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata)))
- .unwrap().move_iter().collect()
+ .unwrap().into_iter().collect()
}
fn read_vtable_origin(&mut self,
cdata: &cstore::crate_metadata) -> Vec<ty::t> {
self.read_to_vec(|this| Ok(this.read_ty_nodcx(tcx, cdata)) )
.unwrap()
- .move_iter()
+ .into_iter()
.collect()
}
}
fn read_tys(&mut self, dcx: &DecodeContext) -> Vec<ty::t> {
- self.read_to_vec(|this| Ok(this.read_ty(dcx))).unwrap().move_iter().collect()
+ self.read_to_vec(|this| Ok(this.read_ty(dcx))).unwrap().into_iter().collect()
}
fn read_trait_ref(&mut self, dcx: &DecodeContext) -> Rc<ty::TraitRef> {
c::tag_table_freevars => {
let fv_info = val_dsr.read_to_vec(|val_dsr| {
Ok(val_dsr.read_freevar_entry(dcx))
- }).unwrap().move_iter().collect();
+ }).unwrap().into_iter().collect();
dcx.tcx.freevars.borrow_mut().insert(id, fv_info);
}
c::tag_table_upvar_borrow_map => {
} else {
Vec::new()
};
- for ge in grouped_errors.mut_iter() {
+ for ge in grouped_errors.iter_mut() {
if move_from_id == ge.move_from.id && error.move_to.is_some() {
debug!("appending move_to to list");
ge.move_to_places.push_all_move(move_to);
ast::ExprIndex(ref l, ref r) |
ast::ExprBinary(_, ref l, ref r) if self.is_method_call(expr) => {
- self.call(expr, pred, &**l, Some(&**r).move_iter())
+ self.call(expr, pred, &**l, Some(&**r).into_iter())
}
ast::ExprUnary(_, ref e) if self.is_method_call(expr) => {
ast::ExprParen(ref e) |
ast::ExprField(ref e, _, _) |
ast::ExprTupField(ref e, _, _) => {
- self.straightline(expr, pred, Some(&**e).move_iter())
+ self.straightline(expr, pred, Some(&**e).into_iter())
}
ast::ExprInlineAsm(ref inline_asm) => {
let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1;
let br = String::from_char(total_width, '+');
try!(write!(f, "{}\n", br));
- for row in pretty_printed_matrix.move_iter() {
+ for row in pretty_printed_matrix.into_iter() {
try!(write!(f, "+"));
- for (column, pat_str) in row.move_iter().enumerate() {
+ for (column, pat_str) in row.into_iter().enumerate() {
try!(write!(f, " "));
f.width = Some(*column_widths.get(column));
try!(f.pad(pat_str.as_slice()));
fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
pats: Vec<&Pat>, left_ty: ty::t) -> P<Pat> {
let pats_len = pats.len();
- let mut pats = pats.move_iter().map(|p| P((*p).clone()));
+ let mut pats = pats.into_iter().map(|p| P((*p).clone()));
let pat = match ty::get(left_ty).sty {
ty::ty_tup(_) => PatTup(pats.collect()),
};
if is_structure {
let fields = ty::lookup_struct_fields(cx.tcx, vid);
- let field_pats: Vec<FieldPat> = fields.move_iter()
+ let field_pats: Vec<FieldPat> = fields.into_iter()
.zip(pats)
.filter(|&(_, ref pat)| pat.node != PatWild(PatWildSingle))
.map(|(field, pat)| FieldPat {
fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix,
left_ty: ty::t, max_slice_length: uint) -> Option<Constructor> {
let used_constructors: Vec<Constructor> = rows.iter()
- .flat_map(|row| pat_constructors(cx, *row.get(0), left_ty, max_slice_length).move_iter())
+ .flat_map(|row| pat_constructors(cx, *row.get(0), left_ty, max_slice_length).into_iter())
.collect();
all_constructors(cx, left_ty, max_slice_length)
- .move_iter()
+ .into_iter()
.find(|c| !used_constructors.contains(c))
}
if constructors.is_empty() {
match missing_constructor(cx, matrix, left_ty, max_slice_length) {
None => {
- all_constructors(cx, left_ty, max_slice_length).move_iter().map(|c| {
+ all_constructors(cx, left_ty, max_slice_length).into_iter().map(|c| {
match is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness) {
UsefulWithWitness(pats) => UsefulWithWitness({
let arity = constructor_arity(cx, &c, left_ty);
});
vec![construct_witness(cx, &c, subpats, left_ty)]
};
- result.extend(pats.move_iter().skip(arity));
+ result.extend(pats.into_iter().skip(arity));
result
}),
result => result
let wild_pats = Vec::from_elem(arity, &DUMMY_WILD_PAT);
let enum_pat = construct_witness(cx, &constructor, wild_pats, left_ty);
let mut new_pats = vec![enum_pat];
- new_pats.extend(pats.move_iter());
+ new_pats.extend(pats.into_iter());
UsefulWithWitness(new_pats)
},
result => result
}
}
} else {
- constructors.move_iter().map(|c|
+ constructors.into_iter().map(|c|
is_useful_specialized(cx, matrix, v, c.clone(), left_ty, witness)
).find(|result| result != &NotUseful).unwrap_or(NotUseful)
}
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let gens = self.gens.mut_slice(start, end);
+ let gens = self.gens.slice_mut(start, end);
set_bit(gens, bit);
}
let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index);
let (start, end) = self.compute_id_range(cfgidx);
- let kills = self.kills.mut_slice(start, end);
+ let kills = self.kills.slice_mut(start, end);
set_bit(kills, bit);
}
}
if changed {
- let bits = self.kills.mut_slice(start, end);
+ let bits = self.kills.slice_mut(start, end);
debug!("{:s} add_kills_from_flow_exits flow_exit={} bits={} [before]",
self.analysis_name, flow_exit, mut_bits_to_string(bits));
bits.copy_from(orig_kills.as_slice());
fn reset(&mut self, bits: &mut [uint]) {
let e = if self.dfcx.oper.initial_value() {uint::MAX} else {0};
- for b in bits.mut_iter() {
+ for b in bits.iter_mut() {
*b = e;
}
}
let (start, end) = self.dfcx.compute_id_range(cfgidx);
let changed = {
// (scoping mutable borrow of self.dfcx.on_entry)
- let on_entry = self.dfcx.on_entry.mut_slice(start, end);
+ let on_entry = self.dfcx.on_entry.slice_mut(start, end);
bitwise(on_entry, pred_bits, &self.dfcx.oper)
};
if changed {
op: &Op) -> bool {
assert_eq!(out_vec.len(), in_vec.len());
let mut changed = false;
- for (out_elt, in_elt) in out_vec.mut_iter().zip(in_vec.iter()) {
+ for (out_elt, in_elt) in out_vec.iter_mut().zip(in_vec.iter()) {
let old_val = *out_elt;
let new_val = op.join(old_val, *in_elt);
*out_elt = new_val;
}
let dead_code = lint::builtin::DEAD_CODE.name_lower();
- for attr in lint::gather_attrs(attrs).move_iter() {
+ for attr in lint::gather_attrs(attrs).into_iter() {
match attr {
Ok((ref name, lint::Allow, _))
if name.get() == dead_code.as_slice() => return true,
fn attempt_static(sess: &session::Session) -> Option<DependencyList> {
let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
if crates.iter().all(|&(_, ref p)| p.is_some()) {
- Some(crates.move_iter().map(|_| Some(cstore::RequireStatic)).collect())
+ Some(crates.into_iter().map(|_| Some(cstore::RequireStatic)).collect())
} else {
None
}
identifier: Ident::new(elem.name()),
lifetimes: vec!(),
types: OwnedSlice::empty()
- }).move_iter().collect(),
+ }).into_iter().collect(),
span: DUMMY_SP,
})
}
if idents.len() == 0 {
return "???".to_string();
}
- self.idents_to_string(idents.move_iter().rev()
+ self.idents_to_string(idents.into_iter().rev()
.collect::<Vec<ast::Ident>>()
.as_slice())
}
}
fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
- self.as_mut_slice().mut_iter()
+ self.as_mut_slice().iter_mut()
}
fn get<'a>(&'a self, index: uint) -> Option<&'a T> {
pub fn sort(t: Vec<T>, space: |&T| -> ParamSpace) -> VecPerParamSpace<T> {
let mut result = VecPerParamSpace::empty();
- for t in t.move_iter() {
+ for t in t.into_iter() {
result.push(space(&t), t);
}
result
pub fn replace(&mut self, space: ParamSpace, elems: Vec<T>) {
// FIXME (#15435): slow; O(n^2); could enhance vec to make it O(n).
self.truncate(space, 0);
- for t in elems.move_iter() {
+ for t in elems.into_iter() {
self.push(space, t);
}
}
pub fn get_mut_slice<'a>(&'a mut self, space: ParamSpace) -> &'a mut [T] {
let (start, limit) = self.limits(space);
- self.content.mut_slice(start, limit)
+ self.content.slice_mut(start, limit)
}
pub fn opt_get<'a>(&'a self,
pub fn map_move<U>(self, pred: |T| -> U) -> VecPerParamSpace<U> {
let (t, s, f) = self.split();
- VecPerParamSpace::new(t.move_iter().map(|p| pred(p)).collect(),
- s.move_iter().map(|p| pred(p)).collect(),
- f.move_iter().map(|p| pred(p)).collect())
+ VecPerParamSpace::new(t.into_iter().map(|p| pred(p)).collect(),
+ s.into_iter().map(|p| pred(p)).collect(),
+ f.into_iter().map(|p| pred(p)).collect())
}
pub fn map_rev<U>(&self, pred: |&T| -> U) -> VecPerParamSpace<U> {
// Now go through all the successful ones,
// registering any nested obligations for the future.
- for selection in selections.move_iter() {
+ for selection in selections.into_iter() {
selection.map_move_nested(
|o| self.register_obligation(tcx, o));
}
}
}
}
-
.iter()
.chain(slice.iter())
.chain(after.iter())
- .zip(extracted.vals.move_iter())
+ .zip(extracted.vals.into_iter())
.fold(bcx, |bcx, (inner, elem)|
bind_irrefutable_pat(bcx, &**inner, elem, binding_mode, cleanup_scope)
);
let mut constraints =
String::from_str(constraints.iter()
.map(|s| s.get().to_string())
- .chain(ext_constraints.move_iter())
+ .chain(ext_constraints.into_iter())
.collect::<Vec<String>>()
.connect(",")
.as_slice());
let arg_scope_id = cleanup::CustomScope(arg_scope);
- for (i, arg_datum) in arg_datums.move_iter().enumerate() {
+ for (i, arg_datum) in arg_datums.into_iter().enumerate() {
// For certain mode/type combinations, the raw llarg values are passed
// by value. However, within the fn body itself, we want to always
// have all locals and arguments be by-ref so that we can cancel the
assert_eq!(arg_datums.len(), 1);
- let arg_datum = arg_datums.move_iter().next().unwrap();
+ let arg_datum = arg_datums.into_iter().next().unwrap();
// Untuple the rest of the arguments.
let tuple_datum =
if !type_is_zero_size(fcx.ccx, result_ty) {
let dest = fcx.get_ret_slot(bcx, result_ty, "eret_slot");
let repr = adt::represent_type(ccx, result_ty);
- for (i, arg_datum) in arg_datums.move_iter().enumerate() {
+ for (i, arg_datum) in arg_datums.into_iter().enumerate() {
let lldestptr = adt::trans_field_ptr(bcx,
&*repr,
dest,
// the final product, so LTO needs to preserve them.
shared_ccx.sess().cstore.iter_crate_data(|cnum, _| {
let syms = csearch::get_reachable_extern_fns(&shared_ccx.sess().cstore, cnum);
- reachable.extend(syms.move_iter().map(|did| {
+ reachable.extend(syms.into_iter().map(|did| {
csearch::get_symbol(&shared_ccx.sess().cstore, did)
}));
});
// we care about.
if ixs.len() < 16 {
let mut small_vec = [ C_i32(self.ccx, 0), ..16 ];
- for (small_vec_e, &ix) in small_vec.mut_iter().zip(ixs.iter()) {
+ for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) {
*small_vec_e = C_i32(self.ccx, ix as i32);
}
self.inbounds_gep(base, small_vec.slice(0, ixs.len()))
}
fn all_mem(cls: &mut [RegClass]) {
- for elt in cls.mut_iter() {
+ for elt in cls.iter_mut() {
*elt = Memory;
}
}
debug!("schedule_clean_in_ast_scope(cleanup_scope={:?})",
cleanup_scope);
- for scope in self.scopes.borrow_mut().mut_iter().rev() {
+ for scope in self.scopes.borrow_mut().iter_mut().rev() {
if scope.kind.is_ast_with_id(cleanup_scope) {
scope.cleanups.push(cleanup);
scope.clear_cached_exits();
// Check if a landing pad block exists; if not, create one.
{
let mut scopes = self.scopes.borrow_mut();
- let last_scope = scopes.mut_last().unwrap();
+ let last_scope = scopes.last_mut().unwrap();
match last_scope.cached_landing_pad {
Some(llbb) => { return llbb; }
None => {
// Copy expr values into boxed bindings.
let mut bcx = bcx;
- for (i, bv) in bound_values.move_iter().enumerate() {
+ for (i, bv) in bound_values.into_iter().enumerate() {
debug!("Copy {} into closure", bv.to_string(ccx));
if ccx.sess().asm_comments() {
adt_reprs: RefCell::new(HashMap::new()),
type_hashcodes: RefCell::new(HashMap::new()),
all_llvm_symbols: RefCell::new(HashSet::new()),
- int_type: Type::from_ref(ptr::mut_null()),
- opaque_vec_type: Type::from_ref(ptr::mut_null()),
+ int_type: Type::from_ref(ptr::null_mut()),
+ opaque_vec_type: Type::from_ref(ptr::null_mut()),
builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
unboxed_closure_vals: RefCell::new(DefIdMap::new()),
dbg_cx: dbg_cx,
type_metadata,
is_local_to_unit,
global,
- ptr::mut_null());
+ ptr::null_mut());
}
})
});
}
};
- if unsafe { llvm::LLVMIsAAllocaInst(llarg.val) } == ptr::mut_null() {
+ if unsafe { llvm::LLVMIsAAllocaInst(llarg.val) } == ptr::null_mut() {
cx.sess().span_bug(span, "debuginfo::create_argument_metadata() - \
Referenced variable location is not an alloca!");
}
cx.sess().opts.optimize != config::No,
llfn,
template_parameters,
- ptr::mut_null())
+ ptr::null_mut())
}
})
});
// Return type -- llvm::DIBuilder wants this at index 0
match fn_decl.output.node {
ast::TyNil => {
- signature.push(ptr::mut_null());
+ signature.push(ptr::null_mut());
}
_ => {
assert_type_for_node_id(cx, fn_ast_id, error_span);
file_metadata,
name,
actual_self_type_metadata,
- ptr::mut_null(),
+ ptr::null_mut(),
0,
0)
}
file_metadata,
name,
actual_type_metadata,
- ptr::mut_null(),
+ ptr::null_mut(),
0,
0)
}
bytes_to_bits(enum_type_size),
bytes_to_bits(enum_type_align),
0, // Flags
- ptr::mut_null(),
+ ptr::null_mut(),
0, // RuntimeLang
unique_type_id_str)
}
bytes_to_bits(struct_size),
bytes_to_bits(struct_align),
0,
- ptr::mut_null(),
+ ptr::null_mut(),
empty_array,
0,
- ptr::mut_null(),
+ ptr::null_mut(),
unique_type_id)
})
})
// return type
signature_metadata.push(match ty::get(signature.output).sty {
- ty::ty_nil => ptr::mut_null(),
+ ty::ty_nil => ptr::null_mut(),
_ => type_metadata(cx, signature.output, span)
});
let col = UNKNOWN_COLUMN_NUMBER;
debug!("setting debug location to {} {}", line, col);
let elements = [C_i32(cx, line as i32), C_i32(cx, col as i32),
- scope, ptr::mut_null()];
+ scope, ptr::null_mut()];
unsafe {
metadata_node = llvm::LLVMMDNodeInContext(debug_context(cx).llcontext,
elements.as_ptr(),
}
UnknownLocation => {
debug!("clearing debug location ");
- metadata_node = ptr::mut_null();
+ metadata_node = ptr::null_mut();
}
};
} else {
None
};
- let mut path = krate.move_iter().chain(path).peekable();
+ let mut path = krate.into_iter().chain(path).peekable();
let mut current_key = Vec::new();
let mut parent_node: Option<Rc<NamespaceTreeNode>> = None;
// create and insert
let parent_scope = match parent_node {
Some(ref node) => node.scope,
- None => ptr::mut_null()
+ None => ptr::null_mut()
};
let namespace_name = token::get_name(name);
let scope = namespace_name.get().with_c_str(|namespace_name| {
parent_scope,
namespace_name,
// cannot reconstruct file ...
- ptr::mut_null(),
+ ptr::null_mut(),
// ... or line information, but that's not so important.
0)
}
let ps = ccx.tcx().map.with_path(id, |path| {
let abi = Some(ast_map::PathName(special_idents::clownshoe_abi.name));
- link::mangle(path.chain(abi.move_iter()), hash)
+ link::mangle(path.chain(abi.into_iter()), hash)
});
// Compute the type that the function would have if it were just a
impl_def_id: id,
substs: substs,
nested: _ }) => {
- emit_vtable_methods(bcx, id, substs).move_iter()
+ emit_vtable_methods(bcx, id, substs).into_iter()
}
traits::VtableUnboxedClosure(closure_def_id) => {
let callee_substs =
}
}
- (vec!(llfn)).move_iter()
+ (vec!(llfn)).into_iter()
}
traits::VtableBuiltin |
traits::VtableParam(..) => {
let _icx = push_ctxt("meth::make_vtable");
let head = vec![drop_glue, size, align];
- let components: Vec<_> = head.move_iter().chain(ptrs).collect();
+ let components: Vec<_> = head.into_iter().chain(ptrs).collect();
unsafe {
let tbl = C_struct(ccx, components.as_slice(), false);
let mut acc = Vec::new();
ty::each_attr(tcx, did, |meta| {
- acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(), meta).move_iter());
+ acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(), meta).into_iter());
true
});
}
match anon_regions {
- Ok(v) => v.move_iter().collect(),
+ Ok(v) => v.into_iter().collect(),
Err(()) => Vec::from_fn(expected_num_region_params,
|_| ty::ReStatic) // hokey
}
};
let input_tys = input_tys.iter().map(|a| ty_of_arg(this, &rb, a, None));
let self_and_input_tys: Vec<_> =
- self_ty.move_iter().chain(input_tys).collect();
+ self_ty.into_iter().chain(input_tys).collect();
// Second, if there was exactly one lifetime (either a substitution or a
// reference) in the arguments, then any anonymous regions in the output
kind_name = "[error]";
arg_types = subpats.clone()
.unwrap_or_default()
- .move_iter()
+ .into_iter()
.map(|_| ty::mk_err())
.collect();
}
// find all the impls of that trait. Each of those are
// candidates.
let opt_applicable_traits = self.fcx.ccx.trait_map.find(&expr_id);
- for applicable_traits in opt_applicable_traits.move_iter() {
+ for applicable_traits in opt_applicable_traits.into_iter() {
for trait_did in applicable_traits.iter() {
debug!("push_extension_candidates() found trait: {}",
if trait_did.krate == ast::LOCAL_CRATE {
let args = fn_sig.inputs.slice_from(1).iter().map(|t| {
t.subst(tcx, &all_substs)
});
- Some(*fn_sig.inputs.get(0)).move_iter().chain(args).collect()
+ Some(*fn_sig.inputs.get(0)).into_iter().chain(args).collect()
}
_ => fn_sig.inputs.subst(tcx, &all_substs)
};
ast::ExprAssignOp(_, ref lhs, ref rhs) => {
if has_method_map {
constrain_call(rcx, expr, Some(&**lhs),
- Some(&**rhs).move_iter(), true);
+ Some(&**rhs).into_iter(), true);
}
adjust_borrow_kind_for_assignment_lhs(rcx, &**lhs);
// implicit "by ref" sort of passing style here. This
// should be converted to an adjustment!
constrain_call(rcx, expr, Some(&**lhs),
- Some(&**rhs).move_iter(), true);
+ Some(&**rhs).into_iter(), true);
visit::walk_expr(rcx, expr);
}
convert_methods(ccx,
ImplContainer(local_def(it.id)),
- methods.move_iter(),
+ methods.into_iter(),
selfty,
&ty_generics,
parent_visibility);
unboxed_fn_ty_bounds } =
astconv::partition_bounds(ccx.tcx, span, all_bounds.as_slice());
let unboxed_fn_ty_bounds =
- unboxed_fn_ty_bounds.move_iter()
+ unboxed_fn_ty_bounds.into_iter()
.map(|b| instantiate_unboxed_fn_ty(ccx, b, param_ty));
let trait_bounds: Vec<Rc<ty::TraitRef>> =
- trait_bounds.move_iter()
+ trait_bounds.into_iter()
.map(|b| instantiate_trait_ref(ccx, b, param_ty.to_ty(ccx.tcx)))
.chain(unboxed_fn_ty_bounds)
.collect();
same_frs: &FreeRegionsFromSameFn) {
let scope_id = same_frs.scope_id;
let (sub_fr, sup_fr) = (same_frs.sub_fr, same_frs.sup_fr);
- for sr in same_regions.mut_iter() {
+ for sr in same_regions.iter_mut() {
if sr.contains(&sup_fr.bound_region)
&& scope_id == sr.scope_id {
sr.push(sub_fr.bound_region);
ast::TyFixedLengthVec(build_to(ty, to), e)
}
ast::TyTup(tys) => {
- ast::TyTup(tys.move_iter().map(|ty| build_to(ty, to)).collect())
+ ast::TyTup(tys.into_iter().map(|ty| build_to(ty, to)).collect())
}
ast::TyParen(typ) => ast::TyParen(build_to(typ, to)),
other => other
/// Register a lint group.
pub fn register_lint_group(&mut self, name: &'static str, to: Vec<&'static Lint>) {
- self.lint_groups.insert(name, to.move_iter().map(|x| LintId::of(x)).collect());
+ self.lint_groups.insert(name, to.into_iter().map(|x| LintId::of(x)).collect());
}
}
debug!("preparing the RPATH!");
let libs = config.used_crates.clone();
- let libs = libs.move_iter().filter_map(|(_, l)| {
+ let libs = libs.into_iter().filter_map(|(_, l)| {
l.map(|p| p.clone())
}).collect::<Vec<_>>();
let buffer_remaining = size - self.buffer_idx;
if input.len() >= buffer_remaining {
copy_memory(
- self.buffer.mut_slice(self.buffer_idx, size),
+ self.buffer.slice_mut(self.buffer_idx, size),
input.slice_to(buffer_remaining));
self.buffer_idx = 0;
func(self.buffer);
i += buffer_remaining;
} else {
copy_memory(
- self.buffer.mut_slice(self.buffer_idx, self.buffer_idx + input.len()),
+ self.buffer.slice_mut(self.buffer_idx, self.buffer_idx + input.len()),
input);
self.buffer_idx += input.len();
return;
// be empty.
let input_remaining = input.len() - i;
copy_memory(
- self.buffer.mut_slice(0, input_remaining),
+ self.buffer.slice_mut(0, input_remaining),
input.slice_from(i));
self.buffer_idx += input_remaining;
}
fn zero_until(&mut self, idx: uint) {
assert!(idx >= self.buffer_idx);
- self.buffer.mut_slice(self.buffer_idx, idx).set_memory(0);
+ self.buffer.slice_mut(self.buffer_idx, idx).set_memory(0);
self.buffer_idx = idx;
}
fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8] {
self.buffer_idx += len;
- return self.buffer.mut_slice(self.buffer_idx - len, self.buffer_idx);
+ return self.buffer.slice_mut(self.buffer_idx - len, self.buffer_idx);
}
fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
)
)
- read_u32v_be(w.mut_slice(0, 16), data);
+ read_u32v_be(w.slice_mut(0, 16), data);
// Putting the message schedule inside the same loop as the round calculations allows for
// the compiler to generate better code.
fn result(&mut self, out: &mut [u8]) {
self.engine.finish();
- write_u32_be(out.mut_slice(0, 4), self.engine.state.h0);
- write_u32_be(out.mut_slice(4, 8), self.engine.state.h1);
- write_u32_be(out.mut_slice(8, 12), self.engine.state.h2);
- write_u32_be(out.mut_slice(12, 16), self.engine.state.h3);
- write_u32_be(out.mut_slice(16, 20), self.engine.state.h4);
- write_u32_be(out.mut_slice(20, 24), self.engine.state.h5);
- write_u32_be(out.mut_slice(24, 28), self.engine.state.h6);
- write_u32_be(out.mut_slice(28, 32), self.engine.state.h7);
+ write_u32_be(out.slice_mut(0, 4), self.engine.state.h0);
+ write_u32_be(out.slice_mut(4, 8), self.engine.state.h1);
+ write_u32_be(out.slice_mut(8, 12), self.engine.state.h2);
+ write_u32_be(out.slice_mut(12, 16), self.engine.state.h3);
+ write_u32_be(out.slice_mut(16, 20), self.engine.state.h4);
+ write_u32_be(out.slice_mut(20, 24), self.engine.state.h5);
+ write_u32_be(out.slice_mut(24, 28), self.engine.state.h6);
+ write_u32_be(out.slice_mut(28, 32), self.engine.state.h7);
}
fn reset(&mut self) {
let expected_vec: Vec<u8> = expected.from_hex()
.unwrap()
- .move_iter()
+ .into_iter()
.collect();
assert_eq!(expected_vec, result_bytes);
}
let did = def.def_id();
if ast_util::is_local(did) { return None }
try_inline_def(cx, tcx, def).map(|vec| {
- vec.move_iter().map(|mut item| {
+ vec.into_iter().map(|mut item| {
match into {
Some(into) if item.name.is_some() => {
item.name = Some(into.clean(cx));
}
def::DefStruct(did) => {
record_extern_fqn(cx, did, clean::TypeStruct);
- ret.extend(build_impls(cx, tcx, did).move_iter());
+ ret.extend(build_impls(cx, tcx, did).into_iter());
clean::StructItem(build_struct(cx, tcx, did))
}
def::DefTy(did) => {
record_extern_fqn(cx, did, clean::TypeEnum);
- ret.extend(build_impls(cx, tcx, did).move_iter());
+ ret.extend(build_impls(cx, tcx, did).into_iter());
build_type(cx, tcx, did)
}
// Assume that the enum type is reexported next to the variant, and
did: ast::DefId) -> Vec<clean::Attribute> {
let mut attrs = Vec::new();
csearch::get_item_attrs(&tcx.sess.cstore, did, |v| {
- attrs.extend(v.move_iter().map(|a| {
+ attrs.extend(v.into_iter().map(|a| {
a.clean(cx)
}));
});
match cx.tcx_opt() {
Some(tcx) => {
let fqn = csearch::get_item_path(tcx, did);
- let fqn = fqn.move_iter().map(|i| i.to_string()).collect();
+ let fqn = fqn.into_iter().map(|i| i.to_string()).collect();
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, kind));
}
None => {}
let def = ty::lookup_trait_def(tcx, did);
let trait_items = ty::trait_items(tcx, did).clean(cx);
let provided = ty::provided_trait_methods(tcx, did);
- let mut items = trait_items.move_iter().map(|trait_item| {
+ let mut items = trait_items.into_iter().map(|trait_item| {
if provided.iter().any(|a| a.def_id == trait_item.def_id) {
clean::ProvidedMethod(trait_item)
} else {
}
}
- impls.move_iter().filter_map(|a| a).collect()
+ impls.into_iter().filter_map(|a| a).collect()
}
fn build_impl(cx: &DocContext, tcx: &ty::ctxt,
}
decoder::DlDef(def) if vis == ast::Public => {
match try_inline_def(cx, tcx, def) {
- Some(i) => items.extend(i.move_iter()),
+ Some(i) => items.extend(i.into_iter()),
None => {}
}
}
_ => unreachable!(),
};
let mut tmp = Vec::new();
- for child in m.items.mut_iter() {
+ for child in m.items.iter_mut() {
let inner = match child.inner {
ModuleItem(ref mut m) => m,
_ => continue,
inner.items.push(i);
}
- m.items.extend(tmp.move_iter());
+ m.items.extend(tmp.into_iter());
}
Crate {
"".to_string()
};
let mut foreigns = Vec::new();
- for subforeigns in self.foreigns.clean(cx).move_iter() {
- for foreign in subforeigns.move_iter() {
+ for subforeigns in self.foreigns.clean(cx).into_iter() {
+ for foreign in subforeigns.into_iter() {
foreigns.push(foreign)
}
}
self.statics.clean(cx),
self.traits.clean(cx),
self.impls.clean(cx),
- self.view_items.clean(cx).move_iter()
- .flat_map(|s| s.move_iter()).collect(),
+ self.view_items.clean(cx).into_iter()
+ .flat_map(|s| s.into_iter()).collect(),
self.macros.clean(cx),
);
external_path(cx, "Sync", &empty)),
};
let fqn = csearch::get_item_path(tcx, did);
- let fqn = fqn.move_iter().map(|i| i.to_string()).collect();
+ let fqn = fqn.into_iter().map(|i| i.to_string()).collect();
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did,
(fqn, TypeTrait));
TraitBound(ResolvedPath {
None => return RegionBound,
};
let fqn = csearch::get_item_path(tcx, self.def_id);
- let fqn = fqn.move_iter().map(|i| i.to_string())
+ let fqn = fqn.into_iter().map(|i| i.to_string())
.collect::<Vec<String>>();
let path = external_path(cx, fqn.last().unwrap().as_slice(),
&self.substs);
fn clean(&self, cx: &DocContext) -> FnDecl {
let (did, sig) = *self;
let mut names = if did.node != 0 {
- csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).move_iter()
+ csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).into_iter()
} else {
- Vec::new().move_iter()
+ Vec::new().into_iter()
}.peekable();
if names.peek().map(|s| s.as_slice()) == Some("self") {
let _ = names.next();
ty::ty_enum(did, ref substs) |
ty::ty_trait(box ty::TyTrait { def_id: did, ref substs, .. }) => {
let fqn = csearch::get_item_path(cx.tcx(), did);
- let fqn: Vec<String> = fqn.move_iter().map(|i| {
+ let fqn: Vec<String> = fqn.into_iter().map(|i| {
i.to_string()
}).collect();
let kind = match ty::get(*self).sty {
generics: self.generics.clean(cx),
trait_: self.trait_.clean(cx),
for_: self.for_.clean(cx),
- items: self.items.clean(cx).move_iter().map(|ti| {
+ items: self.items.clean(cx).into_iter().map(|ti| {
match ti {
MethodImplItem(i) => i,
}
let remaining = list.iter().filter(|path| {
match inline::try_inline(cx, path.node.id(), None) {
Some(items) => {
- ret.extend(items.move_iter()); false
+ ret.extend(items.into_iter()); false
}
None => true,
}
}
ast::ViewPathSimple(ident, _, id) => {
match inline::try_inline(cx, id, Some(ident)) {
- Some(items) => ret.extend(items.move_iter()),
+ Some(items) => ret.extend(items.into_iter()),
None => ret.push(convert(&self.node)),
}
}
None => return fallback(box t.clean(cx)),
};
let fqn = csearch::get_item_path(cx.tcx(), did);
- let fqn: Vec<String> = fqn.move_iter().map(|i| {
+ let fqn: Vec<String> = fqn.into_iter().map(|i| {
i.to_string()
}).collect();
cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, TypeStruct));
span_diagnostic_handler);
let mut cfg = config::build_configuration(&sess);
- for cfg_ in cfgs.move_iter() {
+ for cfg_ in cfgs.into_iter() {
let cfg_ = token::intern_and_get_ident(cfg_.as_slice());
cfg.push(P(codemap::dummy_spanned(ast::MetaWord(cfg_))));
}
libc::FILE_SHARE_READ |
libc::FILE_SHARE_DELETE |
libc::FILE_SHARE_WRITE,
- ptr::mut_null(),
+ ptr::null_mut(),
libc::CREATE_ALWAYS,
libc::FILE_ATTRIBUTE_NORMAL,
- ptr::mut_null())
+ ptr::null_mut())
};
if handle == libc::INVALID_HANDLE_VALUE {
fail!("create file error: {}", os::last_os_error());
StructItem(mut i) => {
let mut foo = Vec::new(); swap(&mut foo, &mut i.fields);
let num_fields = foo.len();
- i.fields.extend(foo.move_iter().filter_map(|x| self.fold_item(x)));
+ i.fields.extend(foo.into_iter().filter_map(|x| self.fold_item(x)));
i.fields_stripped |= num_fields != i.fields.len();
StructItem(i)
},
EnumItem(mut i) => {
let mut foo = Vec::new(); swap(&mut foo, &mut i.variants);
let num_variants = foo.len();
- i.variants.extend(foo.move_iter().filter_map(|x| self.fold_item(x)));
+ i.variants.extend(foo.into_iter().filter_map(|x| self.fold_item(x)));
i.variants_stripped |= num_variants != i.variants.len();
EnumItem(i)
},
}
}
let mut foo = Vec::new(); swap(&mut foo, &mut i.items);
- i.items.extend(foo.move_iter().filter_map(|x| vtrm(self, x)));
+ i.items.extend(foo.into_iter().filter_map(|x| vtrm(self, x)));
TraitItem(i)
},
ImplItem(mut i) => {
let mut foo = Vec::new(); swap(&mut foo, &mut i.items);
- i.items.extend(foo.move_iter()
+ i.items.extend(foo.into_iter()
.filter_map(|x| self.fold_item(x)));
ImplItem(i)
},
let mut foo = Vec::new(); swap(&mut foo, &mut j.fields);
let num_fields = foo.len();
let c = |x| self.fold_item(x);
- j.fields.extend(foo.move_iter().filter_map(c));
+ j.fields.extend(foo.into_iter().filter_map(c));
j.fields_stripped |= num_fields != j.fields.len();
VariantItem(Variant {kind: StructVariant(j), ..i2})
},
fn fold_mod(&mut self, m: Module) -> Module {
Module {
is_crate: m.is_crate,
- items: m.items.move_iter().filter_map(|i| self.fold_item(i)).collect()
+ items: m.items.into_iter().filter_map(|i| self.fold_item(i)).collect()
}
}
let paths: HashMap<ast::DefId, (Vec<String>, ItemType)> =
analysis.as_ref().map(|a| {
let paths = a.external_paths.borrow_mut().take().unwrap();
- paths.move_iter().map(|(k, (v, t))| {
+ paths.into_iter().map(|(k, (v, t))| {
(k, (v, match t {
clean::TypeStruct => item_type::Struct,
clean::TypeEnum => item_type::Enum,
use clean::{FixedVector, Slice, Tuple, PrimitiveTuple};
// extract relevant documentation for this impl
- let dox = match attrs.move_iter().find(|a| {
+ let dox = match attrs.into_iter().find(|a| {
match *a {
clean::NameValue(ref x, _)
if "doc" == x.as_slice() => {
_ => unreachable!()
};
this.sidebar = build_sidebar(&m);
- for item in m.items.move_iter() {
+ for item in m.items.into_iter() {
f(this,item);
}
Ok(())
v.push(myname);
}
- for (_, items) in map.mut_iter() {
+ for (_, items) in map.iter_mut() {
items.as_mut_slice().sort();
}
return map;
// get the thing we just pushed, so we can borrow the string
// out of it with the right lifetime
- let just_inserted = self.chain.mut_last().unwrap();
+ let just_inserted = self.chain.last_mut().unwrap();
just_inserted.sec_number.as_slice()
}
}
pm.add_plugin(plugin);
}
info!("loading plugins...");
- for pname in plugins.move_iter() {
+ for pname in plugins.into_iter() {
pm.load_plugin(pname);
}
// }
let mut json = std::collections::TreeMap::new();
json.insert("schema".to_string(), json::String(SCHEMA_VERSION.to_string()));
- let plugins_json = res.move_iter()
+ let plugins_json = res.into_iter()
.filter_map(|opt| {
match opt {
None => None,
span_diagnostic_handler);
let mut cfg = config::build_configuration(&sess);
- cfg.extend(cfgs.move_iter().map(|cfg_| {
+ cfg.extend(cfgs.into_iter().map(|cfg_| {
let cfg_ = token::intern_and_get_ident(cfg_.as_slice());
P(dummy_spanned(ast::MetaWord(cfg_)))
}));
test_args.insert(0, "rustdoctest".to_string());
testing::test_main(test_args.as_slice(),
- collector.tests.move_iter().collect());
+ collector.tests.into_iter().collect());
0
}
v
};
- for to_run in cur.move_iter() {
+ for to_run in cur.into_iter() {
to_run();
}
}
});
};
- for f in futures.mut_iter() { f.recv() }
+ for f in futures.iter_mut() { f.recv() }
assert_eq!(**total.lock(), num_tasks * count);
}
pub fn new() -> LocalHeap {
LocalHeap {
memory_region: MemoryRegion { live_allocations: 0 },
- live_allocs: ptr::mut_null(),
+ live_allocs: ptr::null_mut(),
}
}
// allocations list
mybox.drop_glue = drop_glue;
mybox.ref_count = 1;
- mybox.prev = ptr::mut_null();
+ mybox.prev = ptr::null_mut();
mybox.next = self.live_allocs;
if !self.live_allocs.is_null() {
unsafe { (*self.live_allocs).prev = alloc; }
//! Walks the internal list of allocations
let mut alloc = self.live_allocs;
- while alloc != ptr::mut_null() {
+ while alloc != ptr::null_mut() {
let next_before = (*alloc).next;
f(self, alloc);
rtabort!("thread-local pointer is null. bogus!");
}
let ptr: Box<T> = mem::transmute(void_ptr);
- tls::set(key, ptr::mut_null());
+ tls::set(key, ptr::null_mut());
return ptr;
}
None
} else {
let ptr: Box<T> = mem::transmute(void_ptr);
- tls::set(key, ptr::mut_null());
+ tls::set(key, ptr::null_mut());
Some(ptr)
}
}
}
pub unsafe fn init_cond() -> uint {
- return CreateEventA(ptr::mut_null(), libc::FALSE, libc::FALSE,
+ return CreateEventA(ptr::null_mut(), libc::FALSE, libc::FALSE,
ptr::null()) as uint;
}
// kernel does, might as well make it explicit. With the current
// 20 kB red zone, that makes for a 64 kB minimum stack.
let stack_size = (cmp::max(stack, RED_ZONE) + 0xfffe) & (-0xfffe - 1);
- let ret = CreateThread(ptr::mut_null(), stack_size as libc::size_t,
- super::thread_start, arg, 0, ptr::mut_null());
+ let ret = CreateThread(ptr::null_mut(), stack_size as libc::size_t,
+ super::thread_start, arg, 0, ptr::null_mut());
if ret as uint == 0 {
// be sure to not leak the closure
}
pub unsafe fn join(native: rust_thread) {
- assert_eq!(pthread_join(native, ptr::mut_null()), 0);
+ assert_eq!(pthread_join(native, ptr::null_mut()), 0);
}
pub unsafe fn detach(native: rust_thread) {
}
impl<'a> FormatWriter for BufWriter<'a> {
fn write(&mut self, bytes: &[u8]) -> fmt::Result {
- let left = self.buf.mut_slice_from(self.pos);
+ let left = self.buf.slice_from_mut(self.pos);
let to_write = bytes.slice_to(cmp::min(bytes.len(), left.len()));
slice::bytes::copy_memory(left, to_write);
self.pos += to_write.len();
use libc::c_int;
use libc;
use std::mem;
-use std::ptr::{null, mut_null};
+use std::ptr::{null, null_mut};
use std::rt::task::BlockedTask;
use std::rt::rtio;
ai_socktype: 0,
ai_protocol: 0,
ai_addrlen: 0,
- ai_canonname: mut_null(),
- ai_addr: mut_null(),
- ai_next: mut_null(),
+ ai_canonname: null_mut(),
+ ai_addr: null_mut(),
+ ai_next: null_mut(),
}
});
let hint_ptr = hint.as_ref().map_or(null(), |x| {
}
unsafe {
- uvll::set_data_for_uv_handle(self.uv_handle(), ptr::mut_null::<()>());
+ uvll::set_data_for_uv_handle(self.uv_handle(), ptr::null_mut::<()>());
uvll::uv_close(self.uv_handle() as *mut uvll::uv_handle_t, close_cb)
}
}
unsafe {
uvll::uv_close(self.uv_handle() as *mut uvll::uv_handle_t, close_cb);
uvll::set_data_for_uv_handle(self.uv_handle(),
- ptr::mut_null::<()>());
+ ptr::null_mut::<()>());
wait_until_woken_after(&mut slot, &self.uv_loop(), || {
uvll::set_data_for_uv_handle(self.uv_handle(), &mut slot);
unsafe {
let data = uvll::get_data_for_uv_handle(handle);
uvll::free_handle(handle);
- if data == ptr::mut_null() { return }
+ if data == ptr::null_mut() { return }
let slot: &mut Option<BlockedTask> = mem::transmute(data);
wakeup(slot);
}
pub fn new(ty: uvll::uv_req_type) -> Request {
unsafe {
let handle = uvll::malloc_req(ty);
- uvll::set_data_for_req(handle, ptr::mut_null::<()>());
+ uvll::set_data_for_req(handle, ptr::null_mut::<()>());
Request::wrap(handle)
}
}
pub unsafe fn get_data<T>(&self) -> &'static mut T {
let data = uvll::get_data_for_req(self.handle);
- assert!(data != ptr::mut_null());
+ assert!(data != ptr::null_mut());
mem::transmute(data)
}
pub fn empty_buf() -> Buf {
uvll::uv_buf_t {
- base: ptr::mut_null(),
+ base: ptr::null_mut(),
len: 0,
}
}
let mut ret_io = Vec::with_capacity(io.len());
unsafe {
stdio.set_len(io.len());
- for (slot, other) in stdio.mut_iter().zip(io.iter()) {
+ for (slot, other) in stdio.iter_mut().zip(io.iter()) {
let io = set_stdio(slot as *mut uvll::uv_stdio_container_t, other,
io_loop);
ret_io.push(io);
let mut req = match self.last_write_req.take() {
Some(req) => req, None => Request::new(uvll::UV_WRITE),
};
- req.set_data(ptr::mut_null::<()>());
+ req.set_data(ptr::null_mut::<()>());
// And here's where timeouts get a little interesting. Currently, libuv
// does not support canceling an in-flight write request. Consequently,
// handle, so our only cleanup is to free the handle itself
if cfg!(windows) {
unsafe { uvll::free_handle(handle); }
- watcher.tty = ptr::mut_null();
+ watcher.tty = ptr::null_mut();
}
Err(UvError(n))
}
match Process::spawn(self, cfg) {
Ok((p, io)) => {
Ok((p as Box<rtio::RtioProcess + Send>,
- io.move_iter().map(|i| i.map(|p| {
+ io.into_iter().map(|i| i.map(|p| {
box p as Box<rtio::RtioPipe + Send>
})).collect()))
}
}
match modulus {
- 0 => Ok(b.move_iter().collect()),
+ 0 => Ok(b.into_iter().collect()),
_ => Err(InvalidHexLength),
}
}
loop {
if self.token == Some(ListEnd) {
- return Ok(List(values.move_iter().collect()));
+ return Ok(List(values.into_iter().collect()));
}
match self.build_value() {
Ok(v) => values.push(v),
};
match o.pop(&"fields".to_string()) {
Some(List(l)) => {
- for field in l.move_iter().rev() {
+ for field in l.into_iter().rev() {
self.stack.push(field);
}
},
debug!("read_seq()");
let list = try!(expect!(self.pop(), List));
let len = list.len();
- for v in list.move_iter().rev() {
+ for v in list.into_iter().rev() {
self.stack.push(v);
}
f(self, len)
debug!("read_map()");
let obj = try!(expect!(self.pop(), Object));
let len = obj.len();
- for (key, value) in obj.move_iter() {
+ for (key, value) in obj.into_iter() {
self.stack.push(value);
self.stack.push(String(key));
}
impl OwnedAsciiExt for Vec<u8> {
#[inline]
fn into_ascii_upper(mut self) -> Vec<u8> {
- for byte in self.mut_iter() {
+ for byte in self.iter_mut() {
*byte = ASCII_UPPER_MAP[*byte as uint];
}
self
#[inline]
fn into_ascii_lower(mut self) -> Vec<u8> {
- for byte in self.mut_iter() {
+ for byte in self.iter_mut() {
*byte = ASCII_LOWER_MAP[*byte as uint];
}
self
/// * base - A raw pointer to a buffer
/// * len - The number of elements in the buffer
pub unsafe fn new(base: *mut T, len: uint) -> CVec<T> {
- assert!(base != ptr::mut_null());
+ assert!(base != ptr::null_mut());
CVec {
base: base,
len: len,
/// for freeing the buffer, etc.
pub unsafe fn new_with_dtor(base: *mut T, len: uint,
dtor: proc():Send) -> CVec<T> {
- assert!(base != ptr::mut_null());
+ assert!(base != ptr::null_mut());
CVec {
base: base,
len: len,
#[should_fail]
fn test_fail_at_null() {
unsafe {
- CVec::new(ptr::mut_null::<u8>(), 9);
+ CVec::new(ptr::null_mut::<u8>(), 9);
}
}
if new_capacity < old_table.capacity() {
// Shrink the table. Naive algorithm for resizing:
- for (h, k, v) in old_table.move_iter() {
+ for (h, k, v) in old_table.into_iter() {
self.insert_hashed_nocheck(h, k, v);
}
} else {
///
/// let new = vec!["a key", "b key", "z key"];
///
- /// for k in new.move_iter() {
+ /// for k in new.into_iter() {
/// map.find_with_or_insert_with(
/// k, "new value",
/// // if the key does exist either prepend or append this
/// map.insert("c", 3);
///
/// // Update all values
- /// for (_, val) in map.mut_iter() {
+ /// for (_, val) in map.iter_mut() {
/// *val *= 2;
/// }
///
/// }
/// ```
pub fn iter_mut(&mut self) -> MutEntries<K, V> {
- MutEntries { inner: self.table.mut_iter() }
+ MutEntries { inner: self.table.iter_mut() }
}
/// Deprecated: use `into_iter`.
/// map.insert("c", 3);
///
/// // Not possible with .iter()
- /// let vec: Vec<(&str, int)> = map.move_iter().collect();
+ /// let vec: Vec<(&str, int)> = map.into_iter().collect();
/// ```
pub fn into_iter(self) -> MoveEntries<K, V> {
MoveEntries {
- inner: self.table.move_iter().map(|(_, k, v)| (k, v))
+ inner: self.table.into_iter().map(|(_, k, v)| (k, v))
}
}
}
drop(hm.clone());
{
- let mut half = hm.move_iter().take(50);
+ let mut half = hm.into_iter().take(50);
let v = drop_vector.get().unwrap();
for i in range(0u, 200) {
#[test]
fn test_keys() {
let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
- let map = vec.move_iter().collect::<HashMap<int, char>>();
+ let map = vec.into_iter().collect::<HashMap<int, char>>();
let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
assert_eq!(keys.len(), 3);
assert!(keys.contains(&1));
#[test]
fn test_values() {
let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
- let map = vec.move_iter().collect::<HashMap<int, char>>();
+ let map = vec.into_iter().collect::<HashMap<int, char>>();
let values = map.values().map(|&v| v).collect::<Vec<char>>();
assert_eq!(values.len(), 3);
assert!(values.contains(&'a'));
let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
- let mut iter = map.mut_iter();
+ let mut iter = map.iter_mut();
for _ in iter.by_ref().take(3) {}
self.map.keys()
}
+ /// Deprecated: use `into_iter`.
+ #[deprecated = "use into_iter"]
+ pub fn move_iter(self) -> SetMoveItems<T> {
+ self.into_iter()
+ }
+
/// Creates a consuming iterator, that is, one that moves each value out
/// of the set in arbitrary order. The set cannot be used after calling
/// this.
/// set.insert("b".to_string());
///
/// // Not possible to collect to a Vec<String> with a regular `.iter()`.
- /// let v: Vec<String> = set.move_iter().collect();
+ /// let v: Vec<String> = set.into_iter().collect();
///
/// // Will print in an arbitrary order.
/// for x in v.iter() {
/// println!("{}", x);
/// }
/// ```
- pub fn move_iter(self) -> SetMoveItems<T> {
- self.map.move_iter().map(|(k, _)| k)
+ pub fn into_iter(self) -> SetMoveItems<T> {
+ self.map.into_iter().map(|(k, _)| k)
}
/// Visit the values representing the difference.
hs
};
- let v = hs.move_iter().collect::<Vec<char>>();
+ let v = hs.into_iter().collect::<Vec<char>>();
assert!(['a', 'b'] == v.as_slice() || ['b', 'a'] == v.as_slice());
}
return;
}
// This is done in reverse because we've likely partially taken
- // some elements out with `.move_iter()` from the front.
+ // some elements out with `.into_iter()` from the front.
// Check if the size is 0, so we don't do a useless scan when
// dropping empty tables such as on resize.
// Also avoid double drop of elements that have been already moved out.
LruEntry {
key: k,
value: v,
- next: ptr::mut_null(),
- prev: ptr::mut_null(),
+ next: ptr::null_mut(),
+ prev: ptr::null_mut(),
}
}
}
}
pub unsafe fn open_internal() -> *mut u8 {
- let mut handle = ptr::mut_null();
+ let mut handle = ptr::null_mut();
GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &mut handle);
handle as *mut u8
}
if buf.len() > self.buf.len() {
self.inner.get_mut_ref().write(buf)
} else {
- let dst = self.buf.mut_slice_from(self.pos);
+ let dst = self.buf.slice_from_mut(self.pos);
slice::bytes::copy_memory(dst, buf);
self.pos += buf.len();
Ok(())
impl<W: Reader> Reader for InternalBufferedWriter<W> {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
- self.get_mut_ref().inner.get_mut_ref().read(buf)
+ self.get_mut().inner.get_mut_ref().read(buf)
}
}
impl<S: Stream> Writer for BufferedStream<S> {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
- self.inner.inner.get_mut_ref().write(buf)
+ self.inner.inner.get_mut().write(buf)
}
fn flush(&mut self) -> IoResult<()> {
- self.inner.inner.get_mut_ref().flush()
+ self.inner.inner.get_mut().flush()
}
}
loop {
match self.buf {
Some(ref prev) => {
- let dst = buf.mut_slice_from(num_read);
+ let dst = buf.slice_from_mut(num_read);
let src = prev.slice_from(self.pos);
let count = cmp::min(dst.len(), src.len());
bytes::copy_memory(dst, src.slice_to(count));
/// at a non-directory file
pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
let err = LocalIo::maybe_raise(|io| {
- Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).move_iter().map(|a| {
+ Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).into_iter().map(|a| {
Path::new(a)
}).collect())
}).map_err(IoError::from_rtio_error);
// delete all regular files in the way and push subdirs
// on the stack
- for child in children.move_iter() {
+ for child in children.into_iter() {
// FIXME(#12795) we should use lstat in all cases
let child_type = match cfg!(windows) {
true => try!(update_err(stat(&child), path)),
{
let mut read_stream = File::open_mode(filename, Open, Read);
{
- let read_buf = read_mem.mut_slice(0, 4);
+ let read_buf = read_mem.slice_mut(0, 4);
check!(read_stream.read(read_buf));
}
{
- let read_buf = read_mem.mut_slice(4, 8);
+ let read_buf = read_mem.slice_mut(4, 8);
check!(read_stream.read(read_buf));
}
}
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = self.buf.slice(self.pos, self.pos + write_len);
- let output = buf.mut_slice(0, write_len);
+ let output = buf.slice_mut(0, write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
}
})
}
- slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf);
+ slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), buf);
self.pos += buf.len();
Ok(())
}
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
let input = self.buf.slice(self.pos, self.pos + write_len);
- let output = buf.mut_slice(0, write_len);
+ let output = buf.slice_mut(0, write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
}
assert!(r.read_at_least(buf.len(), buf).is_ok());
let b: &[_] = &[1, 2, 3];
assert_eq!(buf.as_slice(), b);
- assert!(r.read_at_least(0, buf.mut_slice_to(0)).is_ok());
+ assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
assert_eq!(buf.as_slice(), b);
assert!(r.read_at_least(buf.len(), buf).is_ok());
let b: &[_] = &[4, 5, 6];
while read < min {
let mut zeroes = 0;
loop {
- match self.read(buf.mut_slice_from(read)) {
+ match self.read(buf.slice_from_mut(read)) {
Ok(0) => {
zeroes += 1;
if zeroes >= NO_PROGRESS_LIMIT {
{
let mut start = 1;
while start < width {
- match try!(self.read(buf.mut_slice(start, width))) {
+ match try!(self.read(buf.slice_mut(start, width))) {
n if n == width - start => break,
n if n < width - start => { start += n; }
_ => return Err(standard_error(InvalidInput)),
/// Easy name resolution. Given a hostname, returns the list of IP addresses for
/// that hostname.
pub fn get_host_addresses(host: &str) -> IoResult<Vec<IpAddr>> {
- lookup(Some(host), None, None).map(|a| a.move_iter().map(|i| i.address.ip).collect())
+ lookup(Some(host), None, None).map(|a| a.into_iter().map(|i| i.address.ip).collect())
}
/// Full-fledged resolution. This function will perform a synchronous call to
match LocalIo::maybe_raise(|io| {
io.get_host_addresses(hostname, servname, hint)
}) {
- Ok(v) => Ok(v.move_iter().map(|info| {
+ Ok(v) => Ok(v.into_iter().map(|info| {
Info {
address: SocketAddr {
ip: super::from_rtio(info.address.ip),
// Return result of first successful parser
fn read_or<T>(&mut self, parsers: &mut [|&mut Parser| -> Option<T>])
-> Option<T> {
- for pf in parsers.mut_iter() {
+ for pf in parsers.iter_mut() {
match self.read_atomically(|p: &mut Parser| (*pf)(p)) {
Some(r) => return Some(r),
None => {}
assert!(head.len() + tail.len() <= 8);
let mut gs = [0u16, ..8];
gs.copy_from(head);
- gs.mut_slice(8 - tail.len(), 8).copy_from(tail);
+ gs.slice_mut(8 - tail.len(), 8).copy_from(tail);
Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
}
/// match socket.recv_from(buf) {
/// Ok((amt, src)) => {
/// // Send a reply to the socket we received data from
-/// let buf = buf.mut_slice_to(amt);
+/// let buf = buf.slice_to_mut(amt);
/// buf.reverse();
/// socket.send_to(buf, src);
/// }
None => {
// if the env is currently just inheriting from the parent's,
// materialize the parent's env into a hashtable.
- self.env = Some(os::env_as_bytes().move_iter()
+ self.env = Some(os::env_as_bytes().into_iter()
.map(|(k, v)| (k.as_slice().to_c_str(),
v.as_slice().to_c_str()))
.collect());
detach: self.detach,
};
io.spawn(cfg).map(|(p, io)| {
- let mut io = io.move_iter().map(|p| {
+ let mut io = io.into_iter().map(|p| {
p.map(|p| io::PipeStream::new(p))
});
Process {
pub unsafe fn raise_fd_limit() {
// The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
// sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
- use ptr::mut_null;
+ use ptr::null_mut;
use mem::size_of_val;
use os::last_os_error;
let mut maxfiles: libc::c_int = 0;
let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t;
if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size,
- mut_null(), 0) != 0 {
+ null_mut(), 0) != 0 {
let err = last_os_error();
fail!("raise_fd_limit: error calling sysctl: {}", err);
}
}
let len = cmp::min(self.limit, buf.len());
- let res = self.inner.read(buf.mut_slice_to(len));
+ let res = self.inner.read(buf.slice_to_mut(len));
match res {
Ok(len) => self.limit -= len,
_ => {}
impl Writer for MultiWriter {
#[inline]
fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
- for writer in self.writers.mut_iter() {
+ for writer in self.writers.iter_mut() {
try!(writer.write(buf));
}
Ok(())
#[inline]
fn flush(&mut self) -> io::IoResult<()> {
- for writer in self.writers.mut_iter() {
+ for writer in self.writers.iter_mut() {
try!(writer.flush());
}
Ok(())
#[inline]
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
let mut len = 0;
- for (slot, elt) in buf.mut_iter().zip(self.iter.by_ref()) {
+ for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
*slot = elt;
len += 1;
}
fn test_chained_reader() {
let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()),
MemReader::new(vec!(2, 3)));
- let mut r = ChainedReader::new(rs.move_iter());
+ let mut r = ChainedReader::new(rs.into_iter());
assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap());
}
/// }
/// ```
pub fn env() -> Vec<(String,String)> {
- env_as_bytes().move_iter().map(|(k,v)| {
+ env_as_bytes().into_iter().map(|(k,v)| {
let k = String::from_utf8_lossy(k.as_slice()).into_string();
let v = String::from_utf8_lossy(v.as_slice()).into_string();
(k,v)
-1 as c_int];
let mut sz: libc::size_t = 0;
let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
- ptr::mut_null(), &mut sz, ptr::mut_null(),
+ ptr::null_mut(), &mut sz, ptr::null_mut(),
0u as libc::size_t);
if err != 0 { return None; }
if sz == 0 { return None; }
let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
v.as_mut_ptr() as *mut c_void, &mut sz,
- ptr::mut_null(), 0u as libc::size_t);
+ ptr::null_mut(), 0u as libc::size_t);
if err != 0 { return None; }
if sz == 0 { return None; }
v.set_len(sz as uint - 1); // chop off trailing NUL
unsafe {
use libc::funcs::extra::_NSGetExecutablePath;
let mut sz: u32 = 0;
- _NSGetExecutablePath(ptr::mut_null(), &mut sz);
+ _NSGetExecutablePath(ptr::null_mut(), &mut sz);
if sz == 0 { return None; }
let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz);
unsafe {
let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
- ptr::mut_null(),
+ ptr::null_mut(),
errnum as DWORD,
langId,
buf.as_mut_ptr(),
#[cfg(not(windows))]
fn real_args() -> Vec<String> {
- real_args_as_bytes().move_iter()
+ real_args_as_bytes().into_iter()
.map(|v| {
String::from_utf8_lossy(v.as_slice()).into_string()
}).collect()
#[cfg(windows)]
fn real_args_as_bytes() -> Vec<Vec<u8>> {
- real_args().move_iter().map(|s| s.into_bytes()).collect()
+ real_args().into_iter().map(|s| s.into_bytes()).collect()
}
type LPCWSTR = *const u16;
pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE};
- let mut lpAddress: LPVOID = ptr::mut_null();
+ let mut lpAddress: LPVOID = ptr::null_mut();
let mut readable = false;
let mut writable = false;
let mut executable = false;
unsafe {
let hFile = libc::get_osfhandle(fd) as HANDLE;
let mapping = libc::CreateFileMappingW(hFile,
- ptr::mut_null(),
+ ptr::null_mut(),
flProtect,
0,
0,
ptr::null());
- if mapping == ptr::mut_null() {
+ if mapping == ptr::null_mut() {
return Err(ErrCreateFileMappingW(errno()));
}
if errno() as c_int == libc::ERROR_ALREADY_EXISTS {
let n = if is_abs { comps.len() } else { comps.len() - 1} +
comps.iter().map(|v| v.len()).sum();
let mut v = Vec::with_capacity(n);
- let mut it = comps.move_iter();
+ let mut it = comps.into_iter();
if !is_abs {
match it.next() {
None => (),
assert!(comps == exps, "components: Expected {:?}, found {:?}",
comps, exps);
let comps = path.components().rev().collect::<Vec<&[u8]>>();
- let exps = exps.move_iter().rev().collect::<Vec<&[u8]>>();
+ let exps = exps.into_iter().rev().collect::<Vec<&[u8]>>();
assert!(comps == exps, "rev_components: Expected {:?}, found {:?}",
comps, exps);
}
Some(_) => s.push_str(prefix_),
None => ()
}
- let mut it = comps.move_iter();
+ let mut it = comps.into_iter();
if !is_abs {
match it.next() {
None => (),
//! // where the car is. The game host will never open the door with the car.
//! fn game_host_open<R: Rng>(car: uint, choice: uint, rng: &mut R) -> uint {
//! let choices = free_doors(&[car, choice]);
-//! rand::sample(rng, choices.move_iter(), 1)[0]
+//! rand::sample(rng, choices.into_iter(), 1)[0]
//! }
//!
//! // Returns the door we switch to, given our current choice and
let bytes = path.as_vec();
if bytes.len() < LAST_FILENAME.len() {
let i = bytes.iter();
- for (slot, val) in LAST_FILENAME.mut_iter().zip(i) {
+ for (slot, val) in LAST_FILENAME.iter_mut().zip(i) {
*slot = *val as libc::c_char;
}
LAST_FILENAME.as_ptr()
None => ptr::null(),
};
STATE = backtrace_create_state(filename, 0, error_cb,
- ptr::mut_null());
+ ptr::null_mut());
return STATE
}
#[unsafe_destructor]
impl<T> Drop for TaskPool<T> {
fn drop(&mut self) {
- for channel in self.channels.mut_iter() {
+ for channel in self.channels.iter_mut() {
channel.send(Quit);
}
}
unsafe {
let tmp = Sender::new(Stream(new_inner));
- mem::swap(self.mut_inner(), tmp.mut_inner());
+ mem::swap(self.inner_mut(), tmp.inner_mut());
}
return ret;
}
(*packet.get()).inherit_blocker(sleeper);
let tmp = Sender::new(Shared(packet.clone()));
- mem::swap(self.mut_inner(), tmp.mut_inner());
+ mem::swap(self.inner_mut(), tmp.inner_mut());
}
Sender::new(Shared(packet))
}
#[unsafe_destructor]
impl<T: Send> Drop for Sender<T> {
fn drop(&mut self) {
- match *unsafe { self.mut_inner() } {
+ match *unsafe { self.inner_mut() } {
Oneshot(ref mut p) => unsafe { (*p.get()).drop_chan(); },
Stream(ref mut p) => unsafe { (*p.get()).drop_chan(); },
Shared(ref mut p) => unsafe { (*p.get()).drop_chan(); },
}
};
unsafe {
- mem::swap(self.mut_inner(),
- new_port.mut_inner());
+ mem::swap(self.inner_mut(),
+ new_port.inner_mut());
}
}
}
Sync(ref p) => return unsafe { (*p.get()).recv() }
};
unsafe {
- mem::swap(self.mut_inner(), new_port.mut_inner());
+ mem::swap(self.inner_mut(), new_port.inner_mut());
}
}
}
}
};
unsafe {
- mem::swap(self.mut_inner(),
- new_port.mut_inner());
+ mem::swap(self.inner_mut(),
+ new_port.inner_mut());
}
}
}
};
task = t;
unsafe {
- mem::swap(self.mut_inner(),
- new_port.mut_inner());
+ mem::swap(self.inner_mut(),
+ new_port.inner_mut());
}
}
}
let new_port = match result { Ok(b) => return b, Err(p) => p };
was_upgrade = true;
unsafe {
- mem::swap(self.mut_inner(),
- new_port.mut_inner());
+ mem::swap(self.inner_mut(),
+ new_port.inner_mut());
}
}
}
#[unsafe_destructor]
impl<T: Send> Drop for Receiver<T> {
fn drop(&mut self) {
- match *unsafe { self.mut_inner() } {
+ match *unsafe { self.inner_mut() } {
Oneshot(ref mut p) => unsafe { (*p.get()).drop_port(); },
Stream(ref mut p) => unsafe { (*p.get()).drop_port(); },
Shared(ref mut p) => unsafe { (*p.get()).drop_port(); },
}
}
- for thread in threads.move_iter() {
+ for thread in threads.into_iter() {
thread.join();
}
}
})
}).collect::<Vec<Thread<()>>>();
- for thread in threads.move_iter() {
+ for thread in threads.into_iter() {
thread.join();
}
}
DONE.store(true, SeqCst);
}
- for thread in threads.move_iter() {
+ for thread in threads.into_iter() {
thread.join();
}
unsafe { DONE.store(true, SeqCst); }
- for thread in threads.move_iter() {
+ for thread in threads.into_iter() {
thread.join();
}
}
}
// Wait for children to pass their asserts
- for r in children.mut_iter() {
+ for r in children.iter_mut() {
assert!(r.get_ref().is_ok());
}
assert_eq!(*lock, 42);
*lock = 31337;
// send to other readers
- for &(ref mut rc, _) in reader_convos.mut_iter() {
+ for &(ref mut rc, _) in reader_convos.iter_mut() {
rc.send(())
}
let lock = lock.downgrade();
// complete handshake with other readers
- for &(_, ref mut rp) in reader_convos.mut_iter() {
+ for &(_, ref mut rp) in reader_convos.iter_mut() {
rp.recv()
}
tx1.send(()); // tell writer to try again
});
}
- for rx in completion_rxs.mut_iter() {
+ for rx in completion_rxs.iter_mut() {
assert_eq!(nmsgs, rx.recv());
}
for _ in range(0, nthreads) {
}
// wait until all children get in the mutex
- for rx in rxs.mut_iter() { rx.recv(); }
+ for rx in rxs.iter_mut() { rx.recv(); }
{
let lock = m.lock();
let num_woken = lock.cond.broadcast();
assert_eq!(num_woken, num_waiters);
}
// wait until all children wake up
- for rx in rxs.mut_iter() { rx.recv(); }
+ for rx in rxs.iter_mut() { rx.recv(); }
}
#[test]
fn test_mutex_cond_broadcast() {
}
// wait until all children get in the mutex
- for rx in rxs.mut_iter() { let _ = rx.recv(); }
+ for rx in rxs.iter_mut() { let _ = rx.recv(); }
lock_cond(&x, |cond| {
let num_woken = cond.broadcast();
assert_eq!(num_woken, num_waiters);
});
// wait until all children wake up
- for rx in rxs.mut_iter() { let _ = rx.recv(); }
+ for rx in rxs.iter_mut() { let _ = rx.recv(); }
}
#[test]
fn test_rwlock_cond_broadcast() {
fn path_to_str_with_ident(&self, id: NodeId, i: Ident) -> String {
self.with_path(id, |path| {
- path_to_string(path.chain(Some(PathName(i.name)).move_iter()))
+ path_to_string(path.chain(Some(PathName(i.name)).into_iter()))
})
}
pub fn sort_meta_items(items: Vec<P<MetaItem>>) -> Vec<P<MetaItem>> {
// This is sort of stupid here, but we need to sort by
// human-readable strings.
- let mut v = items.move_iter()
+ let mut v = items.into_iter()
.map(|mi| (mi.name(), mi))
.collect::<Vec<(InternedString, P<MetaItem>)>>();
v.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
// There doesn't seem to be a more optimal way to do this
- v.move_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
+ v.into_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
Spanned {
node: match node {
MetaList(n, mis) => MetaList(n, sort_meta_items(mis)),
}
fn find_escape_frame<'a>(&'a mut self) -> &'a mut MapChainFrame {
- for (i, frame) in self.chain.mut_iter().enumerate().rev() {
+ for (i, frame) in self.chain.iter_mut().enumerate().rev() {
if !frame.info.macros_escape || i == 0 {
return frame
}
types: Vec<P<ast::Ty>> )
-> ast::Path {
let last_identifier = idents.pop().unwrap();
- let mut segments: Vec<ast::PathSegment> = idents.move_iter()
+ let mut segments: Vec<ast::PathSegment> = idents.into_iter()
.map(|ident| {
ast::PathSegment {
identifier: ident,
}
fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Variant {
- let args = tys.move_iter().map(|ty| {
+ let args = tys.into_iter().map(|ty| {
ast::VariantArg { ty: ty, id: ast::DUMMY_NODE_ID }
}).collect();
None => return base::DummyResult::expr(sp)
};
let mut accumulator = String::new();
- for e in es.move_iter() {
+ for e in es.into_iter() {
match e.node {
ast::ExprLit(ref lit) => {
match lit.node {
cs_same_method(|cx, span, exprs| {
// create `a.<method>(); b.<method>(); c.<method>(); ...`
// (where method is `assert_receiver_is_total_eq`)
- let stmts = exprs.move_iter().map(|e| cx.stmt_expr(e)).collect();
+ let stmts = exprs.into_iter().map(|e| cx.stmt_expr(e)).collect();
let block = cx.block(span, stmts, None);
cx.expr_block(block)
},
ast::ItemImpl(trait_generics,
opt_trait_ref,
self_type,
- methods.move_iter()
+ methods.into_iter()
.map(|method| {
ast::MethodImplItem(method)
}).collect()))
_ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable, special_idents::self_))
};
let args = {
- let args = arg_types.move_iter().map(|(name, ty)| {
+ let args = arg_types.into_iter().map(|(name, ty)| {
cx.arg(trait_.span, name, ty)
});
- self_arg.move_iter().chain(args).collect()
+ self_arg.into_iter().chain(args).collect()
};
let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
// transpose raw_fields
let fields = if raw_fields.len() > 0 {
- let mut raw_fields = raw_fields.move_iter().map(|v| v.move_iter());
+ let mut raw_fields = raw_fields.into_iter().map(|v| v.into_iter());
let first_field = raw_fields.next().unwrap();
let mut other_fields: Vec<vec::MoveItems<(Span, Option<Ident>, P<Expr>)>>
= raw_fields.collect();
span: span,
name: opt_id,
self_: field,
- other: other_fields.mut_iter().map(|l| {
+ other: other_fields.iter_mut().map(|l| {
match l.next().unwrap() {
(_, _, ex) => ex
}
// The transposition is driven by walking across the
// arg fields of the variant for the first self pat.
- let field_tuples = first_self_pat_idents.move_iter().enumerate()
+ let field_tuples = first_self_pat_idents.into_iter().enumerate()
// For each arg field of self, pull out its getter expr ...
.map(|(field_index, (sp, opt_ident, self_getter_expr))| {
// ... but FieldInfo also wants getter expr
// struct_type is definitely not Unknown, since struct_def.fields
// must be nonempty to reach here
let pattern = if struct_type == Record {
- let field_pats = subpats.move_iter().zip(ident_expr.iter()).map(|(pat, &(_, id, _))| {
+ let field_pats = subpats.into_iter().zip(ident_expr.iter()).map(|(pat, &(_, id, _))| {
// id is guaranteed to be Some
ast::FieldPat { ident: id.unwrap(), pat: pat }
}).collect();
cs_same_method(
|cx, span, vals| {
if use_foldl {
- vals.move_iter().fold(base.clone(), |old, new| {
+ vals.into_iter().fold(base.clone(), |old, new| {
f(cx, span, old, new)
})
} else {
- vals.move_iter().rev().fold(base.clone(), |old, new| {
+ vals.into_iter().rev().fold(base.clone(), |old, new| {
f(cx, span, old, new)
})
}
return DummyResult::expr(sp);
}
None => return DummyResult::expr(sp),
- Some(exprs) => exprs.move_iter()
+ Some(exprs) => exprs.into_iter()
};
let var = match expr_to_string(cx,
let mut items: SmallVector<P<ast::Item>> = SmallVector::zero();
dec.expand(fld.cx, attr.span, &*attr.node.value, &*it,
|item| items.push(item));
- decorator_items.extend(items.move_iter()
- .flat_map(|item| expand_item(item, fld).move_iter()));
+ decorator_items.extend(items.into_iter()
+ .flat_map(|item| expand_item(item, fld).into_iter()));
fld.cx.bt_pop();
}
SmallVector::zero()
}
Right(Some(items)) => {
- items.move_iter()
+ items.into_iter()
.map(|i| mark_item(i, fm))
- .flat_map(|i| fld.fold_item(i).move_iter())
+ .flat_map(|i| fld.fold_item(i).into_iter())
.collect()
}
Right(None) => {
fld.cx.bt_pop();
if semi {
- fully_expanded.move_iter().map(|s| s.map(|Spanned {node, span}| {
+ fully_expanded.into_iter().map(|s| s.map(|Spanned {node, span}| {
Spanned {
node: match node {
StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
// all of the pats must have the same set of bindings, so use the
// first one to extract them and generate new names:
let idents = pattern_bindings(&**expanded_pats.get(0));
- let new_renames = idents.move_iter().map(|id| (id, fresh_name(&id))).collect();
+ let new_renames = idents.into_iter().map(|id| (id, fresh_name(&id))).collect();
// apply the renaming, but only to the PatIdents:
let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
let rewritten_pats = expanded_pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
// expand the elements of a block.
pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
b.map(|Block {id, view_items, stmts, expr, rules, span}| {
- let new_view_items = view_items.move_iter().map(|x| fld.fold_view_item(x)).collect();
- let new_stmts = stmts.move_iter().flat_map(|x| {
+ let new_view_items = view_items.into_iter().map(|x| fld.fold_view_item(x)).collect();
+ let new_stmts = stmts.into_iter().flat_map(|x| {
// perform all pending renames
let renamed_stmt = {
let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
};
// expand macros in the statement
- fld.fold_stmt(renamed_stmt).move_iter()
+ fld.fold_stmt(renamed_stmt).into_iter()
}).collect();
let new_expr = expr.map(|x| {
let expr = {
};
// expand again if necessary
- new_methods.move_iter().flat_map(|m| fld.fold_method(m).move_iter()).collect()
+ new_methods.into_iter().flat_map(|m| fld.fold_method(m).into_iter()).collect()
}
})
}
cx: &mut cx,
};
- for ExportedMacros { crate_name, macros } in imported_macros.move_iter() {
+ for ExportedMacros { crate_name, macros } in imported_macros.into_iter() {
let name = format!("<{} macros>", token::get_ident(crate_name))
.into_string();
- for source in macros.move_iter() {
+ for source in macros.into_iter() {
let item = parse::parse_item_from_source_str(name.clone(),
source,
expander.cx.cfg(),
}
}
- for (name, extension) in user_exts.move_iter() {
+ for (name, extension) in user_exts.into_iter() {
expander.cx.syntax_env.insert(name, extension);
}
let mut heads = Vec::new();
// First, declare all of our methods that are statics
- for method in self.method_statics.move_iter() {
+ for method in self.method_statics.into_iter() {
let decl = respan(self.fmtsp, ast::DeclItem(method));
lets.push(P(respan(self.fmtsp,
ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID))));
// format! string are shoved into locals. Furthermore, we shove the address
// of each variable because we don't want to move out of the arguments
// passed to this function.
- for (i, e) in self.args.move_iter().enumerate() {
+ for (i, e) in self.args.into_iter().enumerate() {
let arg_ty = match self.arg_types.get(i).as_ref() {
Some(ty) => ty,
None => continue // error already generated
// Now create a vector containing all the arguments
let slicename = self.ecx.ident_of("__args_vec");
{
- let args = names.move_iter().map(|a| a.unwrap());
- let mut args = locals.move_iter().chain(args);
+ let args = names.into_iter().map(|a| a.unwrap());
+ let mut args = locals.into_iter().chain(args);
let args = self.ecx.expr_vec_slice(self.fmtsp, args.collect());
lets.push(self.ecx.stmt_let(self.fmtsp, false, slicename, args));
}
impl<T: ToTokens> ToTokens for Vec<T> {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- let a = self.iter().flat_map(|t| t.to_tokens(cx).move_iter());
+ let a = self.iter().flat_map(|t| t.to_tokens(cx).into_iter());
FromIterator::from_iter(a)
}
}
if token_name_eq(&tok, &EOF) {
if eof_eis.len() == 1u {
let mut v = Vec::new();
- for dv in eof_eis.get_mut(0).matches.mut_iter() {
+ for dv in eof_eis.get_mut(0).matches.iter_mut() {
v.push(dv.pop().unwrap());
}
return Success(nameize(sess, ms, v.as_slice()));
/* done with this set; pop or repeat? */
if should_pop {
let prev = r.stack.pop().unwrap();
- match r.stack.mut_last() {
+ match r.stack.last_mut() {
None => {
r.cur_tok = EOF;
return ret_val;
r.repeat_len.pop();
}
} else { /* repeat */
- *r.repeat_idx.mut_last().unwrap() += 1u;
- r.stack.mut_last().unwrap().idx = 0;
+ *r.repeat_idx.last_mut().unwrap() += 1u;
+ r.stack.last_mut().unwrap().idx = 0;
match r.stack.last().unwrap().sep.clone() {
Some(tk) => {
r.cur_tok = tk; /* repeat same span, I guess */
TTTok(sp, tok) => {
r.cur_span = sp;
r.cur_tok = tok;
- r.stack.mut_last().unwrap().idx += 1;
+ r.stack.last_mut().unwrap().idx += 1;
return ret_val;
}
TTSeq(sp, tts, sep, zerok) => {
"this must repeat at least once");
}
- r.stack.mut_last().unwrap().idx += 1;
+ r.stack.last_mut().unwrap().idx += 1;
return tt_next_token(r);
}
r.repeat_len.push(len);
}
// FIXME #2887: think about span stuff here
TTNonterminal(sp, ident) => {
- r.stack.mut_last().unwrap().idx += 1;
+ r.stack.last_mut().unwrap().idx += 1;
match *lookup_cur_matched(r, ident) {
/* sidestep the interpolation tricks for ident because
(a) idents can be in lots of places, so it'd be a pain
impl<T> MoveMap<T> for Vec<T> {
fn move_map(mut self, f: |T| -> T) -> Vec<T> {
use std::{mem, ptr};
- for p in self.mut_iter() {
+ for p in self.iter_mut() {
unsafe {
// FIXME(#5016) this shouldn't need to zero to be safe.
mem::move_val_init(p, f(ptr::read_and_zero(p)));
node: DeclLocal(fld.fold_local(l)),
span: fld.new_span(span)
})),
- DeclItem(it) => fld.fold_item(it).move_iter().map(|i| P(Spanned {
+ DeclItem(it) => fld.fold_item(it).into_iter().map(|i| P(Spanned {
node: DeclItem(i),
span: fld.new_span(span)
})).collect()
b.map(|Block {id, view_items, stmts, expr, rules, span}| Block {
id: folder.new_id(id),
view_items: view_items.move_map(|x| folder.fold_view_item(x)),
- stmts: stmts.move_iter().flat_map(|s| folder.fold_stmt(s).move_iter()).collect(),
+ stmts: stmts.into_iter().flat_map(|s| folder.fold_stmt(s).into_iter()).collect(),
expr: expr.map(|x| folder.fold_expr(x)),
rules: rules,
span: folder.new_span(span),
ItemImpl(folder.fold_generics(generics),
ifce.map(|p| folder.fold_trait_ref(p)),
folder.fold_ty(ty),
- impl_items.move_iter().flat_map(|impl_item| match impl_item {
+ impl_items.into_iter().flat_map(|impl_item| match impl_item {
MethodImplItem(x) => {
- folder.fold_method(x).move_iter().map(|x| MethodImplItem(x))
+ folder.fold_method(x).into_iter().map(|x| MethodImplItem(x))
}
}).collect())
}
ItemTrait(generics, unbound, bounds, methods) => {
let bounds = folder.fold_bounds(bounds);
- let methods = methods.move_iter().flat_map(|method| match method {
+ let methods = methods.into_iter().flat_map(|method| match method {
RequiredMethod(m) => {
- SmallVector::one(RequiredMethod(folder.fold_type_method(m))).move_iter()
+ SmallVector::one(RequiredMethod(folder.fold_type_method(m))).into_iter()
}
ProvidedMethod(method) => {
// the awkward collect/iter idiom here is because
// they're not actually the same type, so the method arms
// don't unify.
let methods: SmallVector<ast::TraitItem> =
- folder.fold_method(method).move_iter()
+ folder.fold_method(method).into_iter()
.map(|m| ProvidedMethod(m)).collect();
- methods.move_iter()
+ methods.into_iter()
}
}).collect();
ItemTrait(folder.fold_generics(generics),
Mod {
inner: folder.new_span(inner),
view_items: view_items.move_map(|x| folder.fold_view_item(x)),
- items: items.move_iter().flat_map(|x| folder.fold_item(x).move_iter()).collect(),
+ items: items.into_iter().flat_map(|x| folder.fold_item(x).into_iter()).collect(),
}
}
match node {
StmtDecl(d, id) => {
let id = folder.new_id(id);
- folder.fold_decl(d).move_iter().map(|d| P(Spanned {
+ folder.fold_decl(d).into_iter().map(|d| P(Spanned {
node: StmtDecl(d, id),
span: span
})).collect()
impl<T> OwnedSlice<T> {
pub fn empty() -> OwnedSlice<T> {
- OwnedSlice { data: ptr::mut_null(), len: 0 }
+ OwnedSlice { data: ptr::null_mut(), len: 0 }
}
#[inline(never)]
}
pub fn move_iter(self) -> vec::MoveItems<T> {
- self.into_vec().move_iter()
+ self.into_vec().into_iter()
}
pub fn map<U>(&self, f: |&T| -> U) -> OwnedSlice<U> {
let (inner_attrs, body) =
p.parse_inner_attrs_and_block();
let mut attrs = attrs;
- attrs.extend(inner_attrs.move_iter());
+ attrs.extend(inner_attrs.into_iter());
ProvidedMethod(P(ast::Method {
attrs: attrs,
id: ast::DUMMY_NODE_ID,
if ts.len() == 1 && !one_tuple {
self.expect(&token::RPAREN);
- TyParen(ts.move_iter().nth(0).unwrap())
+ TyParen(ts.into_iter().nth(0).unwrap())
} else {
let t = TyTup(ts);
self.expect(&token::RPAREN);
self.commit_expr_expecting(&**es.last().unwrap(), token::RPAREN);
return if es.len() == 1 && !trailing_comma {
- self.mk_expr(lo, hi, ExprParen(es.move_iter().nth(0).unwrap()))
+ self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()))
} else {
self.mk_expr(lo, hi, ExprTup(es))
}
} = self.parse_items_and_view_items(first_item_attrs,
false, false);
- for item in items.move_iter() {
+ for item in items.into_iter() {
let span = item.span;
let decl = P(spanned(span.lo, span.hi, DeclItem(item)));
stmts.push(P(spanned(span.lo, span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))));
"variadic function must be declared with at least one named argument");
}
- let args = args.move_iter().map(|x| x.unwrap()).collect();
+ let args = args.into_iter().map(|x| x.unwrap()).collect();
(args, variadic)
}
seq_sep_trailing_allowed(token::COMMA),
|p| p.parse_ty(true)
);
- for ty in arg_tys.move_iter() {
+ for ty in arg_tys.into_iter() {
args.push(ast::VariantArg {
ty: ty,
id: ast::DUMMY_NODE_ID,
self.bump();
let mut attrs = attrs;
mem::swap(&mut item.attrs, &mut attrs);
- item.attrs.extend(attrs.move_iter());
+ item.attrs.extend(attrs.into_iter());
return IoviItem(P(item));
}
None => {}
let path = ast::Path {
span: span,
global: false,
- segments: path.move_iter().map(|identifier| {
+ segments: path.into_iter().map(|identifier| {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
- segments: path.move_iter().map(|identifier| {
+ segments: path.into_iter().map(|identifier| {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
- segments: path.move_iter().map(|identifier| {
+ segments: path.into_iter().map(|identifier| {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
let path = ast::Path {
span: mk_sp(lo, self.span.hi),
global: false,
- segments: path.move_iter().map(|identifier| {
+ segments: path.into_iter().map(|identifier| {
ast::PathSegment {
identifier: identifier,
lifetimes: Vec::new(),
}
pub fn push_all(&mut self, other: SmallVector<T>) {
- for v in other.move_iter() {
+ for v in other.into_iter() {
self.push(v);
}
}
One(v) => v,
Many(v) => {
if v.len() == 1 {
- v.move_iter().next().unwrap()
+ v.into_iter().next().unwrap()
} else {
fail!(err)
}
}
}
+ /// Deprecated: use `into_iter`.
+ #[deprecated = "use into_iter"]
pub fn move_iter(self) -> MoveItems<T> {
+ self.into_iter()
+ }
+
+ pub fn into_iter(self) -> MoveItems<T> {
let repr = match self.repr {
Zero => ZeroIterator,
One(v) => OneIterator(v),
- Many(vs) => ManyIterator(vs.move_iter())
+ Many(vs) => ManyIterator(vs.into_iter())
};
MoveItems { repr: repr }
}
#[test]
fn test_from_iter() {
- let v: SmallVector<int> = (vec!(1i, 2, 3)).move_iter().collect();
+ let v: SmallVector<int> = (vec!(1i, 2, 3)).into_iter().collect();
assert_eq!(3, v.len());
assert_eq!(&1, v.get(0));
assert_eq!(&2, v.get(1));
#[test]
fn test_move_iter() {
let v = SmallVector::zero();
- let v: Vec<int> = v.move_iter().collect();
+ let v: Vec<int> = v.into_iter().collect();
assert_eq!(Vec::new(), v);
let v = SmallVector::one(1i);
- assert_eq!(vec!(1i), v.move_iter().collect());
+ assert_eq!(vec!(1i), v.into_iter().collect());
let v = SmallVector::many(vec!(1i, 2i, 3i));
- assert_eq!(vec!(1i, 2i, 3i), v.move_iter().collect());
+ assert_eq!(vec!(1i, 2i, 3i), v.into_iter().collect());
}
#[test]
Number(0), Number(0), Number(0), Number(0), Number(0),
Number(0), Number(0), Number(0), Number(0),
];
- for (dst, src) in mparams.mut_iter().zip(params.iter()) {
+ for (dst, src) in mparams.iter_mut().zip(params.iter()) {
*dst = (*src).clone();
}
return Err("non-number on stack with %s".to_string())
}
};
- let mut s: Vec<u8> = s.move_iter().collect();
+ let mut s: Vec<u8> = s.into_iter().collect();
if flags.precision > s.len() {
let mut s_ = Vec::with_capacity(flags.precision);
let n = flags.precision - s.len();
.to_ascii()
.to_upper()
.into_bytes()
- .move_iter()
+ .into_iter()
.collect();
if flags.alternate {
let s_ = replace(&mut s, vec!(b'0', b'X'));
// All benchmarks run at the end, in serial.
// (this includes metric fns)
- for b in filtered_benchs_and_metrics.move_iter() {
+ for b in filtered_benchs_and_metrics.into_iter() {
try!(callback(TeWait(b.desc.clone(), b.testfn.padding())));
run_test(opts, !opts.run_benchmarks, b, tx.clone());
let (test, result, stdout) = rx.recv();
filtered = match opts.filter {
None => filtered,
Some(ref re) => {
- filtered.move_iter()
+ filtered.into_iter()
.filter(|test| re.is_match(test.desc.name.as_slice())).collect()
}
};
None
}
};
- filtered.move_iter().filter_map(|x| filter(x)).collect()
+ filtered.into_iter().filter_map(|x| filter(x)).collect()
};
// Sort the tests alphabetically
match opts.test_shard {
None => filtered,
Some((a,b)) => {
- filtered.move_iter().enumerate()
+ filtered.into_iter().enumerate()
// note: using a - 1 so that the valid shards, for example, are
// 1.2 and 2.2 instead of 0.2 and 1.2
.filter(|&(i,_)| i % b == (a - 1))
}
let result_future = task.try_future(testfn);
- let stdout = reader.read_to_end().unwrap().move_iter().collect();
+ let stdout = reader.read_to_end().unwrap().into_iter().collect();
let task_result = result_future.unwrap();
let test_result = calc_result(&desc, task_result.is_ok());
monitor_ch.send((desc.clone(), test_result, stdout));
loop {
let loop_start = precise_time_ns();
- for p in samples.mut_iter() {
+ for p in samples.iter_mut() {
self.bench_n(n, |x| f(x));
*p = self.ns_per_iter() as f64;
};
stats::winsorize(samples, 5.0);
let summ = stats::Summary::new(samples);
- for p in samples.mut_iter() {
+ for p in samples.iter_mut() {
self.bench_n(5 * n, |x| f(x));
*p = self.ns_per_iter() as f64;
};
let lo = percentile_of_sorted(tmp.as_slice(), pct);
let hundred: T = FromPrimitive::from_uint(100).unwrap();
let hi = percentile_of_sorted(tmp.as_slice(), hundred-pct);
- for samp in samples.mut_iter() {
+ for samp in samples.iter_mut() {
if *samp > hi {
*samp = hi
} else if *samp < lo {
unsafe fn os_get_time() -> (i64, i32) {
use std::ptr;
let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 };
- imp::gettimeofday(&mut tv, ptr::mut_null());
+ imp::gettimeofday(&mut tv, ptr::null_mut());
(tv.tv_sec as i64, tv.tv_usec * 1000)
}
} else if args.len() <= 1u {
vec!("".to_string(), "100000".to_string())
} else {
- args.move_iter().collect()
+ args.into_iter().collect()
};
let n = from_str::<uint>(args.get(1).as_slice()).unwrap();
server(&from_parent, &to_parent);
});
- for r in worker_results.move_iter() {
+ for r in worker_results.into_iter() {
r.unwrap();
}
} else if args.len() <= 1u {
vec!("".to_string(), "10000".to_string(), "4".to_string())
} else {
- args.move_iter().map(|x| x.to_string()).collect()
+ args.into_iter().map(|x| x.to_string()).collect()
};
println!("{}", args);
server(&from_parent, &to_parent);
});
- for r in worker_results.move_iter() {
+ for r in worker_results.into_iter() {
r.unwrap();
}
} else if args.len() <= 1u {
vec!("".to_string(), "10000".to_string(), "4".to_string())
} else {
- args.clone().move_iter().map(|x| x.to_string()).collect()
+ args.clone().into_iter().map(|x| x.to_string()).collect()
};
println!("{:?}", args);
} else if args.len() <= 1u {
vec!("".to_string(), "10".to_string(), "100".to_string())
} else {
- args.clone().move_iter().collect()
+ args.clone().into_iter().collect()
};
let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap();
thread_ring(0, msg_per_task, num_chan, num_port);
// synchronize
- for f in futures.mut_iter() {
+ for f in futures.iter_mut() {
f.get()
}
} else if args.len() <= 1u {
vec!("".to_string(), "10".to_string(), "100".to_string())
} else {
- args.clone().move_iter().collect()
+ args.clone().into_iter().collect()
};
let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap();
thread_ring(0, msg_per_task, num_chan, num_port);
// synchronize
- for f in futures.mut_iter() {
+ for f in futures.iter_mut() {
let _ = f.get();
}
let mut rng = StdRng::new().unwrap();
let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256];
- for x in rgradients.mut_iter() {
+ for x in rgradients.iter_mut() {
*x = random_gradient(&mut rng);
}
let mut permutations = [0i32, ..256];
- for (i, x) in permutations.mut_iter().enumerate() {
+ for (i, x) in permutations.iter_mut().enumerate() {
*x = i as i32;
}
rng.shuffle(permutations);
} else if args.len() <= 1u {
vec!("".to_string(), "8".to_string())
} else {
- args.move_iter().collect()
+ args.into_iter().collect()
};
let n = from_str::<int>(args.get(1).as_slice()).unwrap();
println!("Ack(3,{}): {}\n", n, ack(3, n));
})
}).collect::<Vec<Future<String>>>();
- for message in messages.mut_iter() {
+ for message in messages.iter_mut() {
println!("{}", *message.get_ref());
}
fn rotate(x: &mut [i32]) {
let mut prev = x[0];
- for place in x.mut_iter().rev() {
+ for place in x.iter_mut().rev() {
prev = mem::replace(place, prev)
}
}
fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
for i in range(1, perm.len()) {
- rotate(perm.mut_slice_to(i + 1));
+ rotate(perm.slice_to_mut(i + 1));
let count_i = &mut count[i];
if *count_i >= i as i32 {
*count_i = 0;
fn get(&mut self, mut idx: i32) -> P {
let mut pp = [0u8, .. 16];
self.permcount = idx as u32;
- for (i, place) in self.perm.p.mut_iter().enumerate() {
+ for (i, place) in self.perm.p.iter_mut().enumerate() {
*place = i as i32 + 1;
}
let d = idx / self.fact[i] as i32;
self.cnt[i] = d;
idx %= self.fact[i] as i32;
- for (place, val) in pp.mut_iter().zip(self.perm.p.slice_to(i + 1).iter()) {
+ for (place, val) in pp.iter_mut().zip(self.perm.p.slice_to(i + 1).iter()) {
*place = (*val) as u8
}
fn reverse(tperm: &mut [i32], mut k: uint) {
- tperm.mut_slice_to(k).reverse()
+ tperm.slice_to_mut(k).reverse()
}
fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {
let mut checksum = 0;
let mut maxflips = 0;
- for fut in futures.mut_iter() {
+ for fut in futures.iter_mut() {
let (cs, mf) = fut.get();
checksum += cs;
maxflips = cmp::max(maxflips, mf);
copy_memory(buf.as_mut_slice(), alu);
let buf_len = buf.len();
- copy_memory(buf.mut_slice(alu_len, buf_len),
+ copy_memory(buf.slice_mut(alu_len, buf_len),
alu.slice_to(LINE_LEN));
let mut pos = 0;
fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] {
let mut lookup = [ NULL_AMINO_ACID, ..LOOKUP_SIZE ];
let mut j = 0;
- for (i, slot) in lookup.mut_iter().enumerate() {
+ for (i, slot) in lookup.iter_mut().enumerate() {
while a[j].p < (i as f32) {
j += 1;
}
} else if args.len() <= 1u {
vec!("".to_string(), "30".to_string())
} else {
- args.move_iter().collect()
+ args.into_iter().collect()
};
let n = from_str::<int>(args.get(1).as_slice()).unwrap();
println!("{}\n", fib(n));
let sizes = vec!(1u,2,3,4,6,12,18);
let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<String>()));
let mut from_child = Vec::new();
- let to_child = sizes.iter().zip(streams.mut_iter()).map(|(sz, stream_ref)| {
+ let to_child = sizes.iter().zip(streams.iter_mut()).map(|(sz, stream_ref)| {
let sz = *sz;
let stream = replace(stream_ref, None);
let (to_parent_, from_child_) = stream.unwrap();
{
res.push_all(l.as_slice().trim().as_bytes());
}
- for b in res.mut_iter() {
+ for b in res.iter_mut() {
*b = b.to_ascii().to_upper().to_byte();
}
res
Future::spawn(proc() generate_frequencies(input.as_slice(), occ.len()))
}).collect();
- for (i, freq) in nb_freqs.move_iter() {
+ for (i, freq) in nb_freqs.into_iter() {
print_frequencies(&freq.unwrap(), i);
}
- for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.move_iter()) {
+ for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.into_iter()) {
print_occurrences(&mut freq.unwrap(), occ);
}
}
})
});
- for res in precalc_futures.move_iter() {
+ for res in precalc_futures.into_iter() {
let (rs, is) = res.unwrap();
precalc_r.push_all_move(rs);
precalc_i.push_all_move(is);
});
try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h));
- for res in data.move_iter() {
+ for res in data.into_iter() {
try!(out.write(res.unwrap().as_slice()));
}
out.flush()
}).collect();
// translating to (0, 0) as minimum coordinates.
- for cur_piece in res.mut_iter() {
+ for cur_piece in res.iter_mut() {
let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap();
- for &(ref mut y, ref mut x) in cur_piece.mut_iter() {
+ for &(ref mut y, ref mut x) in cur_piece.iter_mut() {
*y -= dy; *x -= dx;
}
}
// transformation must be taken except for one piece (piece 3
// here).
let transforms: Vec<Vec<Vec<(int, int)>>> =
- pieces.move_iter().enumerate()
+ pieces.into_iter().enumerate()
.map(|(id, p)| transform(p, id != 3))
.collect();
Some(bi) => bi,
None => break
};
- for bj in b_slice.mut_iter() {
+ for bj in b_slice.iter_mut() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
stress_task(i);
}));
}
- for r in results.move_iter() {
+ for r in results.into_iter() {
r.unwrap();
}
}
} else if args.len() <= 1u {
vec!("".to_string(), "8".to_string())
} else {
- args.move_iter().map(|x| x.to_string()).collect()
+ args.into_iter().map(|x| x.to_string()).collect()
};
let opts = parse_opts(args.clone());
(regex!("Y"), "(c|t)"),
];
let mut seq = seq;
- for (re, replacement) in substs.move_iter() {
+ for (re, replacement) in substs.into_iter() {
seq = re.replace_all(seq.as_slice(), NoExpand(replacement));
}
seq.len()
regex!("agggtaa[cgt]|[acg]ttaccct"),
];
let (mut variant_strs, mut counts) = (vec!(), vec!());
- for variant in variants.move_iter() {
+ for variant in variants.into_iter() {
let seq_arc_copy = seq_arc.clone();
variant_strs.push(variant.to_string());
counts.push(Future::spawn(proc() {
('H', 'D'), ('D', 'H'), ('B', 'V'), ('N', 'N'),
('\n', '\n')];
let mut complements: [u8, ..256] = [0, ..256];
- for (i, c) in complements.mut_iter().enumerate() {
+ for (i, c) in complements.iter_mut().enumerate() {
*c = i as u8;
}
let lower = 'A' as u8 - 'a' as u8;
};
let mut data = data.unwrap();
- for seq in data.as_mut_slice().mut_split(|c| *c == '>' as u8) {
+ for seq in data.as_mut_slice().split_mut(|c| *c == '>' as u8) {
// skip header and last \n
let begin = match seq.iter().position(|c| *c == '\n' as u8) {
None => continue,
Some(c) => c
};
let len = seq.len();
- let seq = seq.mut_slice(begin + 1, len - 1);
+ let seq = seq.slice_mut(begin + 1, len - 1);
// arrange line breaks
let len = seq.len();
}
// reverse complement, as
- // seq.reverse(); for c in seq.mut_iter() {*c = complements[*c]}
+ // seq.reverse(); for c in seq.iter_mut() {*c = complements[*c]}
// but faster:
- let mut it = seq.mut_iter();
+ let mut it = seq.iter_mut();
loop {
match (it.next(), it.next_back()) {
(Some(front), Some(back)) => {
} else if args.len() <= 1u {
vec!("".to_string(), "10000".to_string(), "50".to_string())
} else {
- args.move_iter().collect()
+ args.into_iter().collect()
};
let max = from_str::<uint>(args.get(1).as_slice()).unwrap();
let rep = from_str::<uint>(args.get(2).as_slice()).unwrap();
} else if args.len() <= 1 {
vec!("".to_string(), "100".to_string())
} else {
- args.clone().move_iter().collect()
+ args.clone().into_iter().collect()
};
let (tx, rx) = channel();
});
let child_start_chans: Vec<Sender<Sender<int>>> =
- wait_ports.move_iter().map(|port| port.recv()).collect();
+ wait_ports.into_iter().map(|port| port.recv()).collect();
let (start_port, start_chan) = stream::<Sender<int>>();
parent_wait_chan.send(start_chan);
let parent_result_chan: Sender<int> = start_port.recv();
let child_sum_ports: Vec<Reciever<int>> =
- child_start_chans.move_iter().map(|child_start_chan| {
+ child_start_chans.into_iter().map(|child_start_chan| {
let (child_sum_port, child_sum_chan) = stream::<int>();
child_start_chan.send(child_sum_chan);
child_sum_port
}).collect();
- let sum = child_sum_ports.move_iter().fold(0, |sum, sum_port| sum + sum_port.recv() );
+ let sum = child_sum_ports.into_iter().fold(0, |sum, sum_port| sum + sum_port.recv() );
parent_result_chan.send(sum + 1);
}
} else if args.len() <= 1u {
vec!("".to_string(), "10".to_string())
} else {
- args.move_iter().collect()
+ args.into_iter().collect()
};
let n = from_str::<uint>(args.get(1).as_slice()).unwrap();
let mut i = 0u;
use std::rc::Rc;
pub fn main() {
- let _x = Rc::new(vec!(1i, 2)).move_iter();
+ let _x = Rc::new(vec!(1i, 2)).into_iter();
//~^ ERROR cannot move out of dereference of `&`-pointer
}
fn f20() {
let x = vec!("hi".to_string());
- consume(x.move_iter().next().unwrap());
+ consume(x.into_iter().next().unwrap());
touch(x.get(0)); //~ ERROR use of moved value: `x`
}
fn f100() {
let x = vec!("hi".to_string());
- let _y = x.move_iter().next().unwrap();
+ let _y = x.into_iter().next().unwrap();
touch(&x); //~ ERROR use of moved value: `x`
}
fn f110() {
let x = vec!("hi".to_string());
- let _y = [x.move_iter().next().unwrap(), ..1];
+ let _y = [x.into_iter().next().unwrap(), ..1];
touch(&x); //~ ERROR use of moved value: `x`
}
let x = *&x; //~ ERROR: cannot move out of dereference
let x = INIT_ATOMIC_UINT; //~ ERROR cannot move out of static item
let x = *&x; //~ ERROR: cannot move out of dereference
- let x: AtomicPtr<uint> = AtomicPtr::new(ptr::mut_null());
+ let x: AtomicPtr<uint> = AtomicPtr::new(ptr::null_mut());
let x = *&x; //~ ERROR: cannot move out of dereference
let x: AtomicOption<uint> = AtomicOption::empty();
let x = *&x; //~ ERROR: cannot move out of dereference
fn main() {
let mut xs: Vec<int> = vec!();
- for x in xs.mut_iter() {
+ for x in xs.iter_mut() {
xs.push(1i) //~ ERROR cannot borrow `xs`
}
}
let mut_ref2 = (&mut mut_generic_struct, 0i32);
// Raw Pointers
- let mut_ptr1: (*mut Struct1, int) = (ptr::mut_null(), 0);
- let mut_ptr2: (*mut int, int) = (ptr::mut_null(), 0);
- let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::mut_null(), 0);
+ let mut_ptr1: (*mut Struct1, int) = (ptr::null_mut(), 0);
+ let mut_ptr2: (*mut int, int) = (ptr::null_mut(), 0);
+ let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::null_mut(), 0);
let const_ptr1: (*const Struct1, int) = (ptr::null(), 0);
let const_ptr2: (*const int, int) = (ptr::null(), 0);
// except according to those terms.
-fn f<T>(x: Vec<T>) -> T { return x.move_iter().next().unwrap(); }
+fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
fn g(act: |Vec<int> | -> int) -> int { return act(vec!(1, 2, 3)); }
pub fn main() {
unsafe {
for &bare_fn in bare_fns.iter() { bare_fn() }
- for closure in closures.mut_iter() {
+ for closure in closures.iter_mut() {
let S(ref mut closure) = *closure;
(*closure)()
}
let len = (&*c).f.len();
assert!(len == 3);
}
-}
\ No newline at end of file
+}
{
let mut fragments = vec![Fragment, Fragment, Fragment];
let _new_fragments: Vec<Fragment> = mem::replace(&mut fragments, vec![])
- .move_iter()
+ .into_iter()
.skip_while(|_fragment| {
true
}).collect();
fn test2() {
let mut ints = [0i, ..32];
- for i in ints.mut_iter() { *i += 22; }
+ for i in ints.iter_mut() { *i += 22; }
for i in ints.iter() { assert!(*i == 22); }
}
fn myvec_elt<X>(mv: myvec<X>) -> X {
let myvec(v) = mv;
- return v.move_iter().next().unwrap();
+ return v.into_iter().next().unwrap();
}
pub fn main() {
unsafe fn test_triangle() -> bool {
static COUNT : uint = 16;
- let mut ascend = Vec::from_elem(COUNT, ptr::mut_null());
+ let mut ascend = Vec::from_elem(COUNT, ptr::null_mut());
let ascend = ascend.as_mut_slice();
static ALIGN : uint = 1;
println!("type: {}", (*s).clone());
}
- let vec_types: Vec<String> = v.types.clone().move_iter().collect();
+ let vec_types: Vec<String> = v.types.clone().into_iter().collect();
assert_eq!(vec_types, vec!("bool".to_string(), "int".to_string(),
"i8".to_string(), "i16".to_string()));
}
assert_eq!(map.find(&Owned("def".to_string())), Some(&d));
assert!(map.pop(&Slice("foo")).is_some());
- assert_eq!(map.move_iter().map(|(k, v)| format!("{}{}", k, v))
+ assert_eq!(map.into_iter().map(|(k, v)| format!("{}{}", k, v))
.collect::<Vec<String>>()
.concat(),
"abc50bcd51cde52def53".to_string());
}
// Join spawned tasks...
- for r in results.mut_iter() { r.get_ref(); }
+ for r in results.iter_mut() { r.get_ref(); }
println!("Completed: Final number is: ");
println!("{:?}", sum);
fn sub_expr() {
// Test for a &[T] => &&[T] coercion in sub-expression position
// (surpisingly, this can cause errors which are not caused by either of:
- // `let x = vec.mut_slice(0, 2);`
- // `foo(vec.mut_slice(0, 2));` ).
+ // `let x = vec.slice_mut(0, 2);`
+ // `foo(vec.slice_mut(0, 2));` ).
let mut vec: Vec<int> = vec!(1, 2, 3, 4);
let b: &mut [int] = [1, 2];
- assert!(vec.mut_slice(0, 2) == b);
+ assert!(vec.slice_mut(0, 2) == b);
}
fn index() {
projects / rust.git / commitdiff