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

diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index a3b65609b0a37a67e2337a6b05143101777ed9ba..914244cc4319ea695709dd6e353a0cd6979cb5a7 100644 (file)
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -582,7 +582,7 @@ fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
 }
 
 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
@@ -590,8 +590,8 @@ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> DList<A> {
 }
 
 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
index 5ec5db45f275fcac2687354f44fbc82366bf65b4..b03cfced7cdbe869378cebc0e5d44a62fbf273fe 100644 (file)
--- a/src/libcollections/hashmap.rs
+++ b/src/libcollections/hashmap.rs
@@ -1356,7 +1356,7 @@ fn default() -> HashMap<K, V, H> {
     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 @@ fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V, H> {
 }
 
 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 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 }
 
 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 @@ fn from_iterator<I: Iterator<T>>(iter: &mut I) -> HashSet<T, H> {
 }
 
 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
index dc9e5a9700d1585a66ba557610e3d57a59d640d3..65ccfe3ff7080fd9882b56dc0bb37a913bba5f00 100644 (file)
--- a/src/libcollections/priority_queue.rs
+++ b/src/libcollections/priority_queue.rs
@@ -193,22 +193,21 @@ fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
 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
index e083f3f600fcc654633e437616e18305b85b44ca..05a4a2ba5fb31e90191ba4a04bd6fd397db37278 100644 (file)
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -386,7 +386,7 @@ fn ne(&self, other: &RingBuf<A>) -> bool {
 }
 
 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 @@ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> 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
index 5965417bac71b952f6d4481be4dbc2e53e5f7ddc..80886f9608686dd17001487f9b806996b72decb3 100644 (file)
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -971,7 +971,7 @@ fn heir_swap<K: TotalOrd, V>(node: &mut ~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 @@ fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> 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 @@ fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> 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
index 66bcd3cbdda43cfb21a708f96be18d2edd23423b..f1cc9367509ad205cff9c34e2c98fa3e42a094e5 100644 (file)
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -261,7 +261,7 @@ pub fn mut_upper_bound<'a>(&'a mut self, key: uint) -> MutEntries<'a, 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
@@ -269,8 +269,8 @@ fn from_iterator<Iter: Iterator<(uint, T)>>(iter: &mut Iter) -> TrieMap<T> {
 }
 
 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,7 +346,7 @@ pub fn upper_bound<'a>(&'a self, val: uint) -> SetItems<'a> {
 }
 
 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
@@ -354,8 +354,8 @@ fn from_iterator<Iter: Iterator<uint>>(iter: &mut Iter) -> TrieSet {
 }
 
 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
index 1411fe89e6bb5dc0717d99e3f7ca3d1e9f7a7f81..9c017a27faa1fabf3b1979404910f92e74e2efd0 100644 (file)
--- a/src/libglob/lib.rs
+++ b/src/libglob/lib.rs
@@ -153,7 +153,7 @@ fn next(&mut self) -> Option<Path> {
                     // 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
index 50d72663ce8b13c5d91c53c0c57f1dfc45ef813a..86db7cbb625103cbbb840ce79f15533254a81e90 100644 (file)
--- a/src/libnum/bigint.rs
+++ b/src/libnum/bigint.rs
@@ -2185,7 +2185,7 @@ fn test_cmp() {
             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
index f12a2e5a761209bc8c0a3116580f8083d5633076..786be3798a1a01207c3d19ec51edff09f26aea81 100644 (file)
--- 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 @@ fn add_archive(&mut self, archive: &Path, name: &str,
 
         // 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
index 772d92a4f85bad7f60be0c5a2783399432da543a..1e0e38bb45b39ef4a2058bffbbffd905c8a482a5 100644 (file)
--- 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
index fb8f6d4df29d5830c6a784bfe1a41eb37c8b9fbe..1d2e1d0232c348a411d4dcaf39a41daf86811b57 100644 (file)
--- 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
index d7c58f146e1dc04711e775fa857d92bc187ffdcb..684a6624c5e1a7262ec1dbacc1e028d5e00dd090 100644 (file)
--- 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
index f6b9ec329fd35df0ccee9aa94f981d10d81a0352..0098bcfb4b77f682483ef9c0e8e8d121d2393cf8 100644 (file)
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -25,7 +25,7 @@ fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
             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 @@ fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
             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 @@ fn vtrm<T: DocFolder>(this: &mut T, trm: TraitMethod) -> Option<TraitMethod> {
                     }
                 }
                 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 @@ fn vtrm<T: DocFolder>(this: &mut T, trm: TraitMethod) -> Option<TraitMethod> {
                         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
index 8762f23c3cefaced62df51e8523fcfebf43a184d..0a19bc43b281d19ece0ade63ea132683a6d2fe47 100644 (file)
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -76,13 +76,13 @@ trait defined in this module. For loops can be viewed as a syntactical expansion
 /// 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 @@ fn advance(&mut self, f: |A| -> bool) -> bool {
     /// ```
     #[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
index 23363a9784575b50ad90cf3beab15bc3db1e4d79..14dc42195e190f6822b593ba624615f0dfcc5250 100644 (file)
--- 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
index 3596a07eeb242b14ef7ff81c22821572c11d1630..cb4c830f380e2e93952c8c2eaa6c9c7e735b70c7 100644 (file)
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -277,7 +277,7 @@ fn path_relative_from(&self, base: &Path) -> Option<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 @@ fn path_relative_from(&self, base: &Path) -> Option<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
index 9d65a99a0b5e358c7db72b2fc50817d48b8f58db..d488997b0c292c552acd01e07d5e8f9e002e7f54 100644 (file)
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -539,7 +539,7 @@ fn comp_requires_verbatim(s: &str) -> bool {
                     (Some(a), None) => {
                         comps.push(a);
                         if !a_verb {
-                            comps.extend(&mut ita);
+                            comps.extend(ita.by_ref());
                             break;
                         }
                     }
@@ -561,7 +561,7 @@ fn comp_requires_verbatim(s: &str) -> bool {
                         }
                         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
index 5c3a587d9895046a5a3a332365e2ae379502bb84..df1c4ae60ba0b22fa3e64acb6c6ae4e60e0882f6 100644 (file)
--- 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
index 985feaf6ab6533a451a54a1ab787bca389388889..8788a584f30ef1afe654a766e1df376b390de347 100644 (file)
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -2919,10 +2919,10 @@ fn drop(&mut self) {
 pub type RevMoveItems<T> = Rev<MoveItems<T>>;
 
 impl<A> FromIterator<A> for ~[A] {
-    fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
+    fn from_iterator<T: Iterator<A>>(mut iterator: T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
         let mut xs = with_capacity(lower);
-        for x in *iterator {
+        for x in iterator {
             xs.push(x);
         }
         xs
@@ -2930,11 +2930,11 @@ fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
 }
 
 impl<A> Extendable<A> for ~[A] {
-    fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
+    fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         let (lower, _) = iterator.size_hint();
         let len = self.len();
         self.reserve_exact(len + lower);
-        for x in *iterator {
+        for x in iterator {
             self.push(x);
         }
     }

diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 4466439bcbd9d8b501cd2b637f73ea051e551b0a..fac4202217f49c49a89fa5f00c7751c3be2b85a0 100644 (file)
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -3019,7 +3019,7 @@ fn clone(&self) -> ~str {
 
 impl FromIterator<char> for ~str {
     #[inline]
-    fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {
+    fn from_iterator<T: Iterator<char>>(iterator: T) -> ~str {
         let (lower, _) = iterator.size_hint();
         let mut buf = with_capacity(lower);
         buf.extend(iterator);
@@ -3029,11 +3029,11 @@ fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {
 
 impl Extendable<char> for ~str {
     #[inline]
-    fn extend<T: Iterator<char>>(&mut self, iterator: &mut T) {
+    fn extend<T: Iterator<char>>(&mut self, mut iterator: T) {
         let (lower, _) = iterator.size_hint();
         let reserve = lower + self.len();
         self.reserve(reserve);
-        for ch in *iterator {
+        for ch in iterator {
             self.push_char(ch)
         }
     }
@@ -3219,7 +3219,7 @@ fn test_extend() {
         let mut cpy = data.clone();
         let other = "abc";
         let mut it = other.chars();
-        cpy.extend(&mut it);
+        cpy.extend(it);
         assert_eq!(cpy, data + other);
     }
 

diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 5809fca9682e6f920a94e5149d300a459d0d4835..4454801c12946f1d13ccec6353e665a96777743f 100644 (file)
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -305,10 +305,10 @@ fn clone(&self) -> Vec<T> {
 }
 
 impl<T> FromIterator<T> for Vec<T> {
-    fn from_iterator<I:Iterator<T>>(iterator: &mut I) -> Vec<T> {
+    fn from_iterator<I:Iterator<T>>(mut iterator: I) -> Vec<T> {
         let (lower, _) = iterator.size_hint();
         let mut vector = Vec::with_capacity(lower);
-        for element in *iterator {
+        for element in iterator {
             vector.push(element)
         }
         vector
@@ -316,10 +316,10 @@ fn from_iterator<I:Iterator<T>>(iterator: &mut I) -> Vec<T> {
 }
 
 impl<T> Extendable<T> for Vec<T> {
-    fn extend<I: Iterator<T>>(&mut self, iterator: &mut I) {
+    fn extend<I: Iterator<T>>(&mut self, mut iterator: I) {
         let (lower, _) = iterator.size_hint();
         self.reserve_additional(lower);
-        for element in *iterator {
+        for element in iterator {
             self.push(element)
         }
     }
@@ -1429,12 +1429,12 @@ fn test_extend() {
         let mut v = Vec::new();
         let mut w = Vec::new();
 
-        v.extend(&mut range(0, 3));
+        v.extend(range(0, 3));
         for i in range(0, 3) { w.push(i) }
 
         assert_eq!(v, w);
 
-        v.extend(&mut range(3, 10));
+        v.extend(range(3, 10));
         for i in range(3, 10) { w.push(i) }
 
         assert_eq!(v, w);

diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 2f502c1b55f7a57450102d4583775cf4a49a617e..2bcb9c4a229be1ec2fb2e65a635ff62ca7f10c38 100644 (file)
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -359,7 +359,7 @@ pub fn backtrace(&self) -> Option<@ExpnInfo> { self.backtrace }
     pub fn mod_path(&self) -> Vec<ast::Ident> {
         let mut v = Vec::new();
         v.push(token::str_to_ident(self.ecfg.crate_id.name));
-        v.extend(&mut self.mod_path.iter().map(|a| *a));
+        v.extend(self.mod_path.iter().map(|a| *a));
         return v;
     }
     pub fn bt_push(&mut self, ei: codemap::ExpnInfo) {

diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 89a8b2cd336d5d82c8221f5c1e4f9ed0afee34b4..a959e388bcbec6d64dab05aa51e4a3cefc00ae70 100644 (file)
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -365,10 +365,10 @@ fn create_derived_impl(&self,
         let mut ty_params = ty_params.into_vec();
 
         // Copy the lifetimes
-        lifetimes.extend(&mut generics.lifetimes.iter().map(|l| *l));
+        lifetimes.extend(generics.lifetimes.iter().map(|l| *l));
 
         // Create the type parameters.
-        ty_params.extend(&mut generics.ty_params.iter().map(|ty_param| {
+        ty_params.extend(generics.ty_params.iter().map(|ty_param| {
             // I don't think this can be moved out of the loop, since
             // a TyParamBound requires an ast id
             let mut bounds =

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 395bae822a1742c8c0b5cbf2cffb38425d1172b7..e6494bf1aca8a8179d24699c8f26a86a19573a6f 100644 (file)
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -282,7 +282,7 @@ pub fn expand_item(it: @ast::Item, fld: &mut MacroExpander)
                 let mut items: SmallVector<@ast::Item> = SmallVector::zero();
                 dec_fn(fld.cx, attr.span, attr.node.value, it,
                        |item| items.push(item));
-                decorator_items.extend(&mut items.move_iter()
+                decorator_items.extend(items.move_iter()
                     .flat_map(|item| expand_item(item, fld).move_iter()));
 
                 fld.cx.bt_pop();

diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
index d5b90821897f46803803009f8c05bee1ce4e990a..57051e78667149cf37d2644a235cb65f553e1f9d 100644 (file)
--- a/src/libsyntax/owned_slice.rs
+++ b/src/libsyntax/owned_slice.rs
@@ -126,7 +126,7 @@ fn len(&self) -> uint { self.len }
 }
 
 impl<T> FromIterator<T> for OwnedSlice<T> {
-    fn from_iterator<I: Iterator<T>>(iter: &mut I) -> OwnedSlice<T> {
+    fn from_iterator<I: Iterator<T>>(mut iter: I) -> OwnedSlice<T> {
         OwnedSlice::from_vec(iter.collect())
     }
 }

diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index ac2b00bed7656ea0579e92400e89414aa235026a..9d6295e3f28011ef8e4746fa44e52e9f19bd4af4 100644 (file)
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -29,18 +29,16 @@ fn len(&self) -> uint {
 }
 
 impl<T> FromIterator<T> for SmallVector<T> {
-    fn from_iterator<I: Iterator<T>>(iter: &mut I) -> SmallVector<T> {
+    fn from_iterator<I: Iterator<T>>(iter: I) -> SmallVector<T> {
         let mut v = Zero;
-        for val in *iter {
-            v.push(val);
-        }
+        v.extend(iter);
         v
     }
 }
 
 impl<T> Extendable<T> for SmallVector<T> {
-    fn extend<I: Iterator<T>>(&mut self, iter: &mut I) {
-        for val in *iter {
+    fn extend<I: Iterator<T>>(&mut self, mut iter: I) {
+        for val in iter {
             self.push(val);
         }
     }