Removed many pointless calls to *iter() and iter_mut()

Author: Veedrac

src/compiletest/runtest.rs

@@ -285,8 +285,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                             format!("--target={}", config.target),
                             "-L".to_string(),
                             aux_dir.to_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.extend(split_maybe_args(&config.target_rustcflags));
+        args.extend(split_maybe_args(&props.compile_flags));
         return ProcArgs {
             prog: config.rustc_path.to_str().unwrap().to_string(),
             args: args,
@@ -333,8 +333,8 @@ actual:\n\
                             config.build_base.to_str().unwrap().to_string(),
                             "-L".to_string(),
                             aux_dir.to_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.extend(split_maybe_args(&config.target_rustcflags));
+        args.extend(split_maybe_args(&props.compile_flags));
         // FIXME (#9639): This needs to handle non-utf8 paths
         return ProcArgs {
             prog: config.rustc_path.to_str().unwrap().to_string(),
@@ -380,7 +380,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             script_str.push_str(&format!("set solib-search-path \
                                          ./{}/stage2/lib/rustlib/{}/lib/\n",
                                          config.host, config.target));
-            for line in breakpoint_lines.iter() {
+            for line in &breakpoint_lines {
                 script_str.push_str(&format!("break {:?}:{}\n",
                                              testfile.file_name().unwrap()
                                                      .to_string_lossy(),
@@ -1171,7 +1171,7 @@ fn document(config: &Config, props: &TestProps,
                         out_dir.to_str().unwrap().to_string(),
                         testfile.to_str().unwrap().to_string()];
     args.extend(extra_args.iter().cloned());
-    args.extend(split_maybe_args(&props.compile_flags).into_iter());
+    args.extend(split_maybe_args(&props.compile_flags));
     let args = ProcArgs {
         prog: config.rustdoc_path.to_str().unwrap().to_string(),
         args: args,
@@ -1236,7 +1236,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                 vec!("--crate-type=dylib".to_string())
             }
         };
-        crate_type.extend(extra_link_args.clone().into_iter());
+        crate_type.extend(extra_link_args.clone());
         let aux_args =
             make_compile_args(config,
                               &aux_props,
@@ -1334,11 +1334,11 @@ fn make_compile_args<F>(config: &Config,
     };
     args.push(path.to_str().unwrap().to_string());
     if props.force_host {
-        args.extend(split_maybe_args(&config.host_rustcflags).into_iter());
+        args.extend(split_maybe_args(&config.host_rustcflags));
     } else {
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
+        args.extend(split_maybe_args(&config.target_rustcflags));
     }
-    args.extend(split_maybe_args(&props.compile_flags).into_iter());
+    args.extend(split_maybe_args(&props.compile_flags));
     return ProcArgs {
         prog: config.rustc_path.to_str().unwrap().to_string(),
         args: args,
@@ -1373,7 +1373,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path)
     args.push(exe_file.to_str().unwrap().to_string());
 
     // Add the arguments in the run_flags directive
-    args.extend(split_maybe_args(&props.run_flags).into_iter());
+    args.extend(split_maybe_args(&props.run_flags));
 
     let prog = args.remove(0);
     return ProcArgs {
@@ -1683,7 +1683,7 @@ fn compile_test_and_save_ir(config: &Config, props: &TestProps,
                              aux_dir.to_str().unwrap().to_string());
     let llvm_args = vec!("--emit=llvm-ir".to_string(),
                          "--crate-type=lib".to_string());
-    link_args.extend(llvm_args.into_iter());
+    link_args.extend(llvm_args);
     let args = make_compile_args(config,
                                  props,
                                  link_args,

src/error-index-generator/main.rs

@@ -73,7 +73,7 @@ r##"<!DOCTYPE html>
 
     try!(write!(&mut output_file, "<h1>Rust Compiler Error Index</h1>\n"));
 
-    for (err_code, info) in err_map.iter() {
+    for (err_code, info) in err_map {
         // Enclose each error in a div so they can be shown/hidden en masse.
         let desc_desc = match info.description {
             Some(_) => "error-described",

src/liballoc/rc.rs

@@ -130,7 +130,7 @@
 //!     gadget_owner.gadgets.borrow_mut().push(gadget2.clone().downgrade());
 //!
 //!     // Iterate over our Gadgets, printing their details out
-//!     for gadget_opt in gadget_owner.gadgets.borrow().iter() {
+//!     for gadget_opt in &*gadget_owner.gadgets.borrow() {
 //!
 //!         // gadget_opt is a Weak<Gadget>. Since weak pointers can't guarantee
 //!         // that their object is still allocated, we need to call upgrade()

src/libcollections/binary_heap.rs

@@ -85,7 +85,7 @@
 //!
 //!         // For each node we can reach, see if we can find a way with
 //!         // a lower cost going through this node
-//!         for edge in adj_list[position].iter() {
+//!         for edge in &adj_list[position] {
 //!             let next = State { cost: cost + edge.cost, position: edge.node };
 //!
 //!             // If so, add it to the frontier and continue
@@ -450,7 +450,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// let vec = heap.into_vec();
     ///
     /// // Will print in some order
-    /// for x in vec.iter() {
+    /// for x in vec {
     ///     println!("{}", x);
     /// }
     /// ```

src/libcollections/bit.rs

@@ -266,9 +266,9 @@ impl BitVec {
     /// # #![feature(collections)]
     /// use std::collections::BitVec;
     ///
-    /// let mut bv = BitVec::from_elem(10, false);
+    /// let bv = BitVec::from_elem(10, false);
     /// assert_eq!(bv.len(), 10);
-    /// for x in bv.iter() {
+    /// for x in &bv {
     ///     assert_eq!(x, false);
     /// }
     /// ```
@@ -1245,7 +1245,7 @@ impl<'a> IntoIterator for &'a BitVec {
 /// s.union_with(&other);
 ///
 /// // Print 0, 1, 3 in some order
-/// for x in s.iter() {
+/// for x in &s {
 ///     println!("{}", x);
 /// }
 ///
@@ -1370,7 +1370,7 @@ impl BitSet {
     /// let s = BitSet::from_bit_vec(bv);
     ///
     /// // Print 1, 2 in arbitrary order
-    /// for x in s.iter() {
+    /// for x in &s {
     ///     println!("{}", x);
     /// }
     /// ```

src/libcollections/btree/map.rs

@@ -907,7 +907,7 @@ impl<K: Ord, V> Default for BTreeMap<K, V> {
 impl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {
     fn eq(&self, other: &BTreeMap<K, V>) -> bool {
         self.len() == other.len() &&
-            self.iter().zip(other.iter()).all(|(a, b)| a == b)
+            self.iter().zip(other).all(|(a, b)| a == b)
     }
 }
 
@@ -1544,7 +1544,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// for (_, balance) in map.range_mut(Included(&"B"), Excluded(&"Cheryl")) {
     ///     *balance += 100;
     /// }
-    /// for (name, balance) in map.iter() {
+    /// for (name, balance) in &map {
     ///     println!("{} => {}", name, balance);
     /// }
     /// ```

src/libcollections/linked_list.rs

@@ -265,7 +265,7 @@ impl<T> LinkedList<T> {
     ///
     /// a.append(&mut b);
     ///
-    /// for e in a.iter() {
+    /// for e in &a {
     ///     println!("{}", e); // prints 1, then 2, then 3, then 4
     /// }
     /// println!("{}", b.len()); // prints 0
@@ -1189,7 +1189,7 @@ mod tests {
         check_links(&m);
 
         let mut i = 0;
-        for (a, &b) in m.into_iter().zip(v.iter()) {
+        for (a, &b) in m.into_iter().zip(&v) {
             i += 1;
             assert_eq!(a, b);
         }

src/libcollections/slice.rs

@@ -971,7 +971,7 @@ impl<T> [T] {
                reason = "uncertain about this API approach")]
     #[inline]
     pub fn move_from(&mut self, mut src: Vec<T>, start: usize, end: usize) -> usize {
-        for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
+        for (a, b) in self.iter_mut().zip(&mut src[start .. end]) {
             mem::swap(a, b);
         }
         cmp::min(self.len(), end-start)

src/libcollections/str.rs

@@ -1890,7 +1890,7 @@ impl str {
     #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
     pub fn to_uppercase(&self) -> String {
         let mut s = String::with_capacity(self.len());
-        s.extend(self[..].chars().flat_map(|c| c.to_uppercase()));
+        s.extend(self.chars().flat_map(|c| c.to_uppercase()));
         return s;
     }
 

src/libcollections/vec.rs

@@ -1331,7 +1331,7 @@ impl<T:Clone> Clone for Vec<T> {
         }
 
         // reuse the contained values' allocations/resources.
-        for (place, thing) in self.iter_mut().zip(other.iter()) {
+        for (place, thing) in self.iter_mut().zip(other) {
             place.clone_from(thing)
         }