Changed iter::Extendable and iter::FromIterator to take a Iterator by value

Kimundi · Kimundi · commit 6200e761f0ef · 2014-03-25T21:49:55.000+01:00
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
@@ -582,16 +582,16 @@ impl<A> DoubleEndedIterator<A> for MoveItems<A> {
 }
 
 impl<A> FromIterator<A> for DList<A> {
-    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> DList<A> {
+    fn from_iterator<T: Iterator<A>>(iterator: T) -> DList<A> {
         let mut ret = DList::new();
         ret.extend(iterator);
         ret
     }
 }
 
 impl<A> Extendable<A> for DList<A> {
-    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
-        for elt in *iterator { self.push_back(elt); }
+    fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
+        for elt in iterator { self.push_back(elt); }
     }
 }
 
diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs
@@ -1356,7 +1356,7 @@ pub type Values<'a, K, V> =
     iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
 
 impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
-    fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V, H> {
+    fn from_iterator<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {
         let (lower, _) = iter.size_hint();
         let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
         map.extend(iter);
@@ -1365,8 +1365,8 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> fo
 }
 
 impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashMap<K, V, H> {
-    fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {
-        for (k, v) in *iter {
+    fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
+        for (k, v) in iter {
             self.insert(k, v);
         }
     }
@@ -1540,7 +1540,7 @@ impl<T: TotalEq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T,
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
-    fn from_iterator<I: Iterator<T>>(iter: &mut I) -> HashSet<T, H> {
+    fn from_iterator<I: Iterator<T>>(iter: I) -> HashSet<T, H> {
         let (lower, _) = iter.size_hint();
         let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());
         set.extend(iter);
@@ -1549,8 +1549,8 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSe
 }
 
 impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> Extendable<T> for HashSet<T, H> {
-    fn extend<I: Iterator<T>>(&mut self, iter: &mut I) {
-        for k in *iter {
+    fn extend<I: Iterator<T>>(&mut self, mut iter: I) {
+        for k in iter {
             self.insert(k);
         }
     }
diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs
@@ -193,22 +193,21 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
 }
 
 impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
-    fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> PriorityQueue<T> {
+    fn from_iterator<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {
         let mut q = PriorityQueue::new();
         q.extend(iter);
-
         q
     }
 }
 
 impl<T: Ord> Extendable<T> for PriorityQueue<T> {
-    fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {
+    fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 
         let len = self.capacity();
         self.reserve(len + lower);
 
-        for elem in *iter {
+        for elem in iter {
             self.push(elem);
         }
     }
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
@@ -386,7 +386,7 @@ impl<A: Eq> Eq for RingBuf<A> {
 }
 
 impl<A> FromIterator<A> for RingBuf<A> {
-    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> RingBuf<A> {
+    fn from_iterator<T: Iterator<A>>(iterator: T) -> RingBuf<A> {
         let (lower, _) = iterator.size_hint();
         let mut deq = RingBuf::with_capacity(lower);
         deq.extend(iterator);
@@ -395,8 +395,8 @@ impl<A> FromIterator<A> for RingBuf<A> {
 }
 
 impl<A> Extendable<A> for RingBuf<A> {
-    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
-        for elt in *iterator {
+    fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
+        for elt in iterator {
             self.push_back(elt);
         }
     }
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
@@ -971,7 +971,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
 }
 
 impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {
-    fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> TreeMap<K, V> {
+    fn from_iterator<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
         let mut map = TreeMap::new();
         map.extend(iter);
         map
@@ -980,15 +980,15 @@ impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {
 
 impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {
     #[inline]
-    fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {
-        for (k, v) in *iter {
+    fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
+        for (k, v) in iter {
             self.insert(k, v);
         }
     }
 }
 
 impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {
-    fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> TreeSet<T> {
+    fn from_iterator<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
         let mut set = TreeSet::new();
         set.extend(iter);
         set
@@ -997,8 +997,8 @@ impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {
 
 impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
     #[inline]
-    fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {
-        for elem in *iter {
+    fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
+        for elem in iter {
             self.insert(elem);
         }
     }
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
@@ -261,16 +261,16 @@ impl<T> TrieMap<T> {
 }
 
 impl<T> FromIterator<(uint, T)> for TrieMap<T> {
-    fn from_iterator<Iter: Iterator<(uint, T)>>(iter: &mut Iter) -> TrieMap<T> {
+    fn from_iterator<Iter: Iterator<(uint, T)>>(iter: Iter) -> TrieMap<T> {
         let mut map = TrieMap::new();
         map.extend(iter);
         map
     }
 }
 
 impl<T> Extendable<(uint, T)> for TrieMap<T> {
-    fn extend<Iter: Iterator<(uint, T)>>(&mut self, iter: &mut Iter) {
-        for (k, v) in *iter {
+    fn extend<Iter: Iterator<(uint, T)>>(&mut self, mut iter: Iter) {
+        for (k, v) in iter {
             self.insert(k, v);
         }
     }
@@ -346,16 +346,16 @@ impl TrieSet {
 }
 
 impl FromIterator<uint> for TrieSet {
-    fn from_iterator<Iter: Iterator<uint>>(iter: &mut Iter) -> TrieSet {
+    fn from_iterator<Iter: Iterator<uint>>(iter: Iter) -> TrieSet {
         let mut set = TrieSet::new();
         set.extend(iter);
         set
     }
 }
 
 impl Extendable<uint> for TrieSet {
-    fn extend<Iter: Iterator<uint>>(&mut self, iter: &mut Iter) {
-        for elem in *iter {
+    fn extend<Iter: Iterator<uint>>(&mut self, mut iter: Iter) {
+        for elem in iter {
             self.insert(elem);
         }
     }
diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs
@@ -153,7 +153,7 @@ impl Iterator<Path> for Paths {
                     // so we don't need to check the children
                     return Some(path);
                 } else {
-                    self.todo.extend(&mut list_dir_sorted(&path).move_iter().map(|x|(x,idx+1)));
+                    self.todo.extend(list_dir_sorted(&path).move_iter().map(|x|(x,idx+1)));
                 }
             }
         }
diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
@@ -2185,7 +2185,7 @@ mod bigint_tests {
             nums.push(BigInt::from_slice(Minus, *s));
         }
         nums.push(Zero::zero());
-        nums.extend(&mut vs.iter().map(|s| BigInt::from_slice(Plus, *s)));
+        nums.extend(vs.iter().map(|s| BigInt::from_slice(Plus, *s)));
 
         for (i, ni) in nums.iter().enumerate() {
             for (j0, nj) in nums.slice(i, nums.len()).iter().enumerate() {
diff --git a/src/librustc/back/archive.rs b/src/librustc/back/archive.rs
@@ -41,8 +41,8 @@ fn run_ar(sess: &Session, args: &str, cwd: Option<&Path>,
     let ar = get_ar_prog(sess);
 
     let mut args = vec!(args.to_owned());
-    let mut paths = paths.iter().map(|p| p.as_str().unwrap().to_owned());
-    args.extend(&mut paths);
+    let paths = paths.iter().map(|p| p.as_str().unwrap().to_owned());
+    args.extend(paths);
     debug!("{} {}", ar, args.connect(" "));
     match cwd {
         Some(p) => { debug!("inside {}", p.display()); }
@@ -190,7 +190,7 @@ impl<'a> Archive<'a> {
 
         // Finally, add all the renamed files to this archive
         let mut args = vec!(&self.dst);
-        args.extend(&mut inputs.iter());
+        args.extend(inputs.iter());
         run_ar(self.sess, "r", None, args.as_slice());
         Ok(())
     }
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
@@ -496,7 +496,7 @@ pub fn collect_crate_types(session: &Session,
         return vec!(CrateTypeExecutable)
     }
     let mut base = session.opts.crate_types.clone();
-    let mut iter = attrs.iter().filter_map(|a| {
+    let iter = attrs.iter().filter_map(|a| {
         if a.name().equiv(&("crate_type")) {
             match a.value_str() {
                 Some(ref n) if n.equiv(&("rlib")) => Some(CrateTypeRlib),
@@ -525,7 +525,7 @@ pub fn collect_crate_types(session: &Session,
             None
         }
     });
-    base.extend(&mut iter);
+    base.extend(iter);
     if base.len() == 0 {
         base.push(CrateTypeExecutable);
     }
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
@@ -476,7 +476,7 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,
         }
         None => {}
     }
-    llargs.extend(&mut args.iter().map(|arg| arg.val));
+    llargs.extend(args.iter().map(|arg| arg.val));
 
     let retval = Call(bcx, fn_ptr, llargs.as_slice(), []);
     if type_is_zero_size(ccx, f.sig.output) || fcx.llretptr.get().is_some() {
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
@@ -57,8 +57,8 @@ pub fn type_of_rust_fn(cx: &CrateContext, has_env: bool,
     }
 
     // ... then explicit args.
-    let mut input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty));
-    atys.extend(&mut input_tys);
+    let input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty));
+    atys.extend(input_tys);
 
     // Use the output as the actual return value if it's immediate.
     if use_out_pointer || return_type_is_void(cx, output) {
diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
@@ -25,7 +25,7 @@ pub trait DocFolder {
             StructItem(mut i) => {
                 let mut foo = Vec::new(); swap(&mut foo, &mut i.fields);
                 let num_fields = foo.len();
-                i.fields.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
+                i.fields.extend(foo.move_iter().filter_map(|x| self.fold_item(x)));
                 i.fields_stripped |= num_fields != i.fields.len();
                 StructItem(i)
             },
@@ -35,7 +35,7 @@ pub trait DocFolder {
             EnumItem(mut i) => {
                 let mut foo = Vec::new(); swap(&mut foo, &mut i.variants);
                 let num_variants = foo.len();
-                i.variants.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
+                i.variants.extend(foo.move_iter().filter_map(|x| self.fold_item(x)));
                 i.variants_stripped |= num_variants != i.variants.len();
                 EnumItem(i)
             },
@@ -57,12 +57,12 @@ pub trait DocFolder {
                     }
                 }
                 let mut foo = Vec::new(); swap(&mut foo, &mut i.methods);
-                i.methods.extend(&mut foo.move_iter().filter_map(|x| vtrm(self, x)));
+                i.methods.extend(foo.move_iter().filter_map(|x| vtrm(self, x)));
                 TraitItem(i)
             },
             ImplItem(mut i) => {
                 let mut foo = Vec::new(); swap(&mut foo, &mut i.methods);
-                i.methods.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
+                i.methods.extend(foo.move_iter().filter_map(|x| self.fold_item(x)));
                 ImplItem(i)
             },
             VariantItem(i) => {
@@ -72,7 +72,7 @@ pub trait DocFolder {
                         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(&mut foo.move_iter().filter_map(c));
+                        j.fields.extend(foo.move_iter().filter_map(c));
                         j.fields_stripped |= num_fields != j.fields.len();
                         VariantItem(Variant {kind: StructVariant(j), ..i2})
                     },
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
@@ -76,13 +76,13 @@ use mem;
 /// Conversion from an `Iterator`
 pub trait FromIterator<A> {
     /// Build a container with elements from an external iterator.
-    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> Self;
+    fn from_iterator<T: Iterator<A>>(iterator: T) -> Self;
 }
 
 /// A type growable from an `Iterator` implementation
 pub trait Extendable<A>: FromIterator<A> {
     /// Extend a container with the elements yielded by an iterator
-    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T);
+    fn extend<T: Iterator<A>>(&mut self, iterator: T);
 }
 
 /// An interface for dealing with "external iterators". These types of iterators
@@ -460,7 +460,7 @@ pub trait Iterator<A> {
     /// ```
     #[inline]
     fn collect<B: FromIterator<A>>(&mut self) -> B {
-        FromIterator::from_iterator(self)
+        FromIterator::from_iterator(self.by_ref())
     }
 
     /// Loops through `n` iterations, returning the `n`th element of the
@@ -2336,7 +2336,7 @@ mod tests {
     #[test]
     fn test_counter_from_iter() {
         let mut it = count(0, 5).take(10);
-        let xs: ~[int] = FromIterator::from_iterator(&mut it);
+        let xs: ~[int] = FromIterator::from_iterator(it);
         assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
     }
 
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
@@ -593,7 +593,7 @@ pub fn collect<T, Iter: Iterator<Option<T>>, V: FromIterator<T>>(iter: Iter) ->
         }
     });
 
-    let v: V = FromIterator::from_iterator(&mut iter);
+    let v: V = FromIterator::from_iterator(iter.by_ref());
 
     if iter.state {
         None
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
@@ -277,7 +277,7 @@ impl GenericPath for Path {
                     (None, None) => break,
                     (Some(a), None) => {
                         comps.push(a);
-                        comps.extend(&mut ita);
+                        comps.extend(ita.by_ref());
                         break;
                     }
                     (None, _) => comps.push(dot_dot_static),
@@ -290,7 +290,7 @@ impl GenericPath for Path {
                             comps.push(dot_dot_static);
                         }
                         comps.push(a);
-                        comps.extend(&mut ita);
+                        comps.extend(ita.by_ref());
                         break;
                     }
                 }
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
@@ -539,7 +539,7 @@ impl GenericPath for Path {
                     (Some(a), None) => {
                         comps.push(a);
                         if !a_verb {
-                            comps.extend(&mut ita);
+                            comps.extend(ita.by_ref());
                             break;
                         }
                     }
@@ -561,7 +561,7 @@ impl GenericPath for Path {
                         }
                         comps.push(a);
                         if !a_verb {
-                            comps.extend(&mut ita);
+                            comps.extend(ita.by_ref());
                             break;
                         }
                     }
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
@@ -230,7 +230,7 @@ pub fn collect<T, E, Iter: Iterator<Result<T, E>>, V: FromIterator<T>>(iter: Ite
         }
     });
 
-    let v: V = FromIterator::from_iterator(&mut iter);
+    let v: V = FromIterator::from_iterator(iter.by_ref());
 
     match iter.state {
         Some(err) => Err(err),
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs

Original file line number	Diff line number	Diff line change
`@@ -582,16 +582,16 @@ impl<A> DoubleEndedIterator<A> for MoveItems<A> {`
`582`	`582`	`}`
`583`	`583`
`584`	`584`	`impl<A> FromIterator<A> for DList<A> {`
`585`		`- fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> DList<A> {`
	`585`	`+ fn from_iterator<T: Iterator<A>>(iterator: T) -> DList<A> {`
`586`	`586`	`let mut ret = DList::new();`
`587`	`587`	`ret.extend(iterator);`
`588`	`588`	`ret`
`589`	`589`	`}`
`590`	`590`	`}`
`591`	`591`
`592`	`592`	`impl<A> Extendable<A> for DList<A> {`
`593`		`- fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {`
`594`		`- for elt in *iterator { self.push_back(elt); }`
	`593`	`+ fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {`
	`594`	`+ for elt in iterator { self.push_back(elt); }`
`595`	`595`	`}`
`596`	`596`	`}`
`597`	`597`
Original file line number	Diff line number	Diff line change
`@@ -1356,7 +1356,7 @@ pub type Values<'a, K, V> =`
`1356`	`1356`	`iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;`
`1357`	`1357`
`1358`	`1358`	`impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {`
`1359`		`- fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V, H> {`
	`1359`	`+ fn from_iterator<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {`
`1360`	`1360`	`let (lower, _) = iter.size_hint();`
`1361`	`1361`	`let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());`
`1362`	`1362`	`map.extend(iter);`
`@@ -1365,8 +1365,8 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> fo`
`1365`	`1365`	`}`
`1366`	`1366`
`1367`	`1367`	`impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashMap<K, V, H> {`
`1368`		`- fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {`
`1369`		`- for (k, v) in *iter {`
	`1368`	`+ fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {`
	`1369`	`+ for (k, v) in iter {`
`1370`	`1370`	`self.insert(k, v);`
`1371`	`1371`	`}`
`1372`	`1372`	`}`
`@@ -1540,7 +1540,7 @@ impl<T: TotalEq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T,`
`1540`	`1540`	`}`
`1541`	`1541`
`1542`	`1542`	`impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {`
`1543`		`- fn from_iterator<I: Iterator<T>>(iter: &mut I) -> HashSet<T, H> {`
	`1543`	`+ fn from_iterator<I: Iterator<T>>(iter: I) -> HashSet<T, H> {`
`1544`	`1544`	`let (lower, _) = iter.size_hint();`
`1545`	`1545`	`let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());`
`1546`	`1546`	`set.extend(iter);`
`@@ -1549,8 +1549,8 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSe`
`1549`	`1549`	`}`
`1550`	`1550`
`1551`	`1551`	`impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> Extendable<T> for HashSet<T, H> {`
`1552`		`- fn extend<I: Iterator<T>>(&mut self, iter: &mut I) {`
`1553`		`- for k in *iter {`
	`1552`	`+ fn extend<I: Iterator<T>>(&mut self, mut iter: I) {`
	`1553`	`+ for k in iter {`
`1554`	`1554`	`self.insert(k);`
`1555`	`1555`	`}`
`1556`	`1556`	`}`
Original file line number	Diff line number	Diff line change
`@@ -193,22 +193,21 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`impl<T: Ord> FromIterator<T> for PriorityQueue<T> {`
`196`		`- fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> PriorityQueue<T> {`
	`196`	`+ fn from_iterator<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {`
`197`	`197`	`let mut q = PriorityQueue::new();`
`198`	`198`	`q.extend(iter);`
`199`		`-`
`200`	`199`	`q`
`201`	`200`	`}`
`202`	`201`	`}`
`203`	`202`
`204`	`203`	`impl<T: Ord> Extendable<T> for PriorityQueue<T> {`
`205`		`- fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {`
	`204`	`+ fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {`
`206`	`205`	`let (lower, _) = iter.size_hint();`
`207`	`206`
`208`	`207`	`let len = self.capacity();`
`209`	`208`	`self.reserve(len + lower);`
`210`	`209`
`211`		`- for elem in *iter {`
	`210`	`+ for elem in iter {`
`212`	`211`	`self.push(elem);`
`213`	`212`	`}`
`214`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -386,7 +386,7 @@ impl<A: Eq> Eq for RingBuf<A> {`
`386`	`386`	`}`
`387`	`387`
`388`	`388`	`impl<A> FromIterator<A> for RingBuf<A> {`
`389`		`- fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> RingBuf<A> {`
	`389`	`+ fn from_iterator<T: Iterator<A>>(iterator: T) -> RingBuf<A> {`
`390`	`390`	`let (lower, _) = iterator.size_hint();`
`391`	`391`	`let mut deq = RingBuf::with_capacity(lower);`
`392`	`392`	`deq.extend(iterator);`
`@@ -395,8 +395,8 @@ impl<A> FromIterator<A> for RingBuf<A> {`
`395`	`395`	`}`
`396`	`396`
`397`	`397`	`impl<A> Extendable<A> for RingBuf<A> {`
`398`		`- fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {`
`399`		`- for elt in *iterator {`
	`398`	`+ fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {`
	`399`	`+ for elt in iterator {`
`400`	`400`	`self.push_back(elt);`
`401`	`401`	`}`
`402`	`402`	`}`
Original file line number	Diff line number	Diff line change
`@@ -971,7 +971,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,`
`971`	`971`	`}`
`972`	`972`
`973`	`973`	`impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {`
`974`		`- fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> TreeMap<K, V> {`
	`974`	`+ fn from_iterator<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {`
`975`	`975`	`let mut map = TreeMap::new();`
`976`	`976`	`map.extend(iter);`
`977`	`977`	`map`
`@@ -980,15 +980,15 @@ impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {`
`980`	`980`
`981`	`981`	`impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {`
`982`	`982`	`#[inline]`
`983`		`- fn extend<T: Iterator<(K, V)>>(&mut self, iter: &mut T) {`
`984`		`- for (k, v) in *iter {`
	`983`	`+ fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {`
	`984`	`+ for (k, v) in iter {`
`985`	`985`	`self.insert(k, v);`
`986`	`986`	`}`
`987`	`987`	`}`
`988`	`988`	`}`
`989`	`989`
`990`	`990`	`impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {`
`991`		`- fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> TreeSet<T> {`
	`991`	`+ fn from_iterator<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {`
`992`	`992`	`let mut set = TreeSet::new();`
`993`	`993`	`set.extend(iter);`
`994`	`994`	`set`
`@@ -997,8 +997,8 @@ impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {`
`997`	`997`
`998`	`998`	`impl<T: TotalOrd> Extendable<T> for TreeSet<T> {`
`999`	`999`	`#[inline]`
`1000`		`- fn extend<Iter: Iterator<T>>(&mut self, iter: &mut Iter) {`
`1001`		`- for elem in *iter {`
	`1000`	`+ fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {`
	`1001`	`+ for elem in iter {`
`1002`	`1002`	`self.insert(elem);`
`1003`	`1003`	`}`
`1004`	`1004`	`}`
Original file line number	Diff line number	Diff line change
`@@ -261,16 +261,16 @@ impl<T> TrieMap<T> {`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`impl<T> FromIterator<(uint, T)> for TrieMap<T> {`
`264`		`- fn from_iterator<Iter: Iterator<(uint, T)>>(iter: &mut Iter) -> TrieMap<T> {`
	`264`	`+ fn from_iterator<Iter: Iterator<(uint, T)>>(iter: Iter) -> TrieMap<T> {`
`265`	`265`	`let mut map = TrieMap::new();`
`266`	`266`	`map.extend(iter);`
`267`	`267`	`map`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`impl<T> Extendable<(uint, T)> for TrieMap<T> {`
`272`		`- fn extend<Iter: Iterator<(uint, T)>>(&mut self, iter: &mut Iter) {`
`273`		`- for (k, v) in *iter {`
	`272`	`+ fn extend<Iter: Iterator<(uint, T)>>(&mut self, mut iter: Iter) {`
	`273`	`+ for (k, v) in iter {`
`274`	`274`	`self.insert(k, v);`
`275`	`275`	`}`
`276`	`276`	`}`
`@@ -346,16 +346,16 @@ impl TrieSet {`
`346`	`346`	`}`
`347`	`347`
`348`	`348`	`impl FromIterator<uint> for TrieSet {`
`349`		`- fn from_iterator<Iter: Iterator<uint>>(iter: &mut Iter) -> TrieSet {`
	`349`	`+ fn from_iterator<Iter: Iterator<uint>>(iter: Iter) -> TrieSet {`
`350`	`350`	`let mut set = TrieSet::new();`
`351`	`351`	`set.extend(iter);`
`352`	`352`	`set`
`353`	`353`	`}`
`354`	`354`	`}`
`355`	`355`
`356`	`356`	`impl Extendable<uint> for TrieSet {`
`357`		`- fn extend<Iter: Iterator<uint>>(&mut self, iter: &mut Iter) {`
`358`		`- for elem in *iter {`
	`357`	`+ fn extend<Iter: Iterator<uint>>(&mut self, mut iter: Iter) {`
	`358`	`+ for elem in iter {`
`359`	`359`	`self.insert(elem);`
`360`	`360`	`}`
`361`	`361`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ impl Iterator<Path> for Paths {`
`153`	`153`	`// so we don't need to check the children`
`154`	`154`	`return Some(path);`
`155`	`155`	`} else {`
`156`		`- self.todo.extend(&mut list_dir_sorted(&path).move_iter().map(\|x\|(x,idx+1)));`
	`156`	`+ self.todo.extend(list_dir_sorted(&path).move_iter().map(\|x\|(x,idx+1)));`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2185,7 +2185,7 @@ mod bigint_tests {`
`2185`	`2185`	`nums.push(BigInt::from_slice(Minus, *s));`
`2186`	`2186`	`}`
`2187`	`2187`	`nums.push(Zero::zero());`
`2188`		`- nums.extend(&mut vs.iter().map(\|s\| BigInt::from_slice(Plus, *s)));`
	`2188`	`+ nums.extend(vs.iter().map(\|s\| BigInt::from_slice(Plus, *s)));`
`2189`	`2189`
`2190`	`2190`	`for (i, ni) in nums.iter().enumerate() {`
`2191`	`2191`	`for (j0, nj) in nums.slice(i, nums.len()).iter().enumerate() {`
Original file line number	Diff line number	Diff line change
`@@ -496,7 +496,7 @@ pub fn collect_crate_types(session: &Session,`
`496`	`496`	`return vec!(CrateTypeExecutable)`
`497`	`497`	`}`
`498`	`498`	`let mut base = session.opts.crate_types.clone();`
`499`		`- let mut iter = attrs.iter().filter_map(\|a\| {`
	`499`	`+ let iter = attrs.iter().filter_map(\|a\| {`
`500`	`500`	`if a.name().equiv(&("crate_type")) {`
`501`	`501`	`match a.value_str() {`
`502`	`502`	`Some(ref n) if n.equiv(&("rlib")) => Some(CrateTypeRlib),`
`@@ -525,7 +525,7 @@ pub fn collect_crate_types(session: &Session,`
`525`	`525`	`None`
`526`	`526`	`}`
`527`	`527`	`});`
`528`		`- base.extend(&mut iter);`
	`528`	`+ base.extend(iter);`
`529`	`529`	`if base.len() == 0 {`
`530`	`530`	`base.push(CrateTypeExecutable);`
`531`	`531`	`}`
Original file line number	Diff line number	Diff line change
`@@ -476,7 +476,7 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,`
`476`	`476`	`}`
`477`	`477`	`None => {}`
`478`	`478`	`}`
`479`		`- llargs.extend(&mut args.iter().map(\|arg\| arg.val));`
	`479`	`+ llargs.extend(args.iter().map(\|arg\| arg.val));`
`480`	`480`
`481`	`481`	`let retval = Call(bcx, fn_ptr, llargs.as_slice(), []);`
`482`	`482`	`if type_is_zero_size(ccx, f.sig.output) \|\| fcx.llretptr.get().is_some() {`