Fix other bugs with new closure borrowing

This fixes various issues throughout the standard distribution and tests.

6 files changed, 23 insertions, 22 deletions

diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index f61b282767f..7621a7ec4cd 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -107,9 +107,9 @@ impl<'a> Parser<'a> {
     }
 
     // Return result of first successful parser
-    fn read_or<T>(&mut self, parsers: &[|&mut Parser| -> Option<T>])
+    fn read_or<T>(&mut self, parsers: &mut [|&mut Parser| -> Option<T>])
                -> Option<T> {
-        for pf in parsers.iter() {
+        for pf in parsers.mut_iter() {
             match self.read_atomically(|p: &mut Parser| (*pf)(p)) {
                 Some(r) => return Some(r),
                 None => {}
@@ -305,7 +305,7 @@ impl<'a> Parser<'a> {
     fn read_ip_addr(&mut self) -> Option<IpAddr> {
         let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr();
         let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr();
-        self.read_or([ipv4_addr, ipv6_addr])
+        self.read_or(&mut [ipv4_addr, ipv6_addr])
     }
 
     fn read_socket_addr(&mut self) -> Option<SocketAddr> {
@@ -318,7 +318,7 @@ impl<'a> Parser<'a> {
                 p.read_seq_3::<char, IpAddr, char>(open_br, ip_addr, clos_br)
                         .map(|t| match t { (_, ip, _) => ip })
             };
-            p.read_or([ipv4_p, ipv6_p])
+            p.read_or(&mut [ipv4_p, ipv6_p])
         };
         let colon = |p: &mut Parser| p.read_given_char(':');
         let port  = |p: &mut Parser| p.read_number(10, 5, 0x10000).map(|n| n as u16);
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index ec5d7390164..d895331752f 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -1241,7 +1241,7 @@ pub struct Map<'a, A, B, T> {
 
 impl<'a, A, B, T> Map<'a, A, B, T> {
     #[inline]
-    fn do_map(&self, elt: Option<A>) -> Option<B> {
+    fn do_map(&mut self, elt: Option<A>) -> Option<B> {
         match elt {
             Some(a) => Some((self.f)(a)),
             _ => None
@@ -1824,7 +1824,7 @@ pub struct Inspect<'a, A, T> {
 
 impl<'a, A, T> Inspect<'a, A, T> {
     #[inline]
-    fn do_inspect(&self, elt: Option<A>) -> Option<A> {
+    fn do_inspect(&mut self, elt: Option<A>) -> Option<A> {
         match elt {
             Some(ref a) => (self.f)(a),
             None => ()
@@ -2910,7 +2910,7 @@ mod tests {
         let xs = [1, 2, 3, 4, 5];
 
         // test .map and .inspect that don't implement Clone
-        let it = xs.iter().inspect(|_| {});
+        let mut it = xs.iter().inspect(|_| {});
         assert_eq!(xs.len(), it.indexable());
         for (i, elt) in xs.iter().enumerate() {
             assert_eq!(Some(elt), it.idx(i));
@@ -2922,7 +2922,7 @@ mod tests {
     fn test_random_access_map() {
         let xs = [1, 2, 3, 4, 5];
 
-        let it = xs.iter().map(|x| *x);
+        let mut it = xs.iter().map(|x| *x);
         assert_eq!(xs.len(), it.indexable());
         for (i, elt) in xs.iter().enumerate() {
             assert_eq!(Some(*elt), it.idx(i));
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 557e2043381..efbb1abacfa 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -873,9 +873,9 @@ mod tests {
         assert_eq!(v, None);
 
         // test that it does not take more elements than it needs
-        let functions = [|| Some(()), || None, || fail!()];
+        let mut functions = [|| Some(()), || None, || fail!()];
 
-        let v: Option<~[()]> = collect(functions.iter().map(|f| (*f)()));
+        let v: Option<~[()]> = collect(functions.mut_iter().map(|f| (*f)()));
 
         assert_eq!(v, None);
     }
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 7080da266f6..058548eb151 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -695,9 +695,9 @@ mod tests {
         assert_eq!(v, Err(2));
 
         // test that it does not take more elements than it needs
-        let functions = [|| Ok(()), || Err(1), || fail!()];
+        let mut functions = [|| Ok(()), || Err(1), || fail!()];
 
-        let v: Result<~[()], int> = collect(functions.iter().map(|f| (*f)()));
+        let v: Result<~[()], int> = collect(functions.mut_iter().map(|f| (*f)()));
         assert_eq!(v, Err(1));
     }
 
@@ -715,9 +715,9 @@ mod tests {
                    Err(2));
 
         // test that it does not take more elements than it needs
-        let functions = [|| Ok(()), || Err(1), || fail!()];
+        let mut functions = [|| Ok(()), || Err(1), || fail!()];
 
-        assert_eq!(fold_(functions.iter()
+        assert_eq!(fold_(functions.mut_iter()
                         .map(|f| (*f)())),
                    Err(1));
     }
diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index 309ea8623e5..f9f919edaaa 100644
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -212,8 +212,7 @@ impl<'a, T> Iterator<&'a [T]> for RevSplits<'a, T> {
             return Some(self.v);
         }
 
-        let pred = &mut self.pred;
-        match self.v.iter().rposition(|x| (*pred)(x)) {
+        match self.v.iter().rposition(|x| (self.pred)(x)) {
             None => {
                 self.finished = true;
                 Some(self.v)
@@ -2132,7 +2131,8 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> {
     fn next(&mut self) -> Option<&'a mut [T]> {
         if self.finished { return None; }
 
-        match self.v.iter().position(|x| (self.pred)(x)) {
+        let pred = &mut self.pred;
+        match self.v.iter().position(|x| (*pred)(x)) {
             None => {
                 self.finished = true;
                 let tmp = mem::replace(&mut self.v, &mut []);
@@ -2167,7 +2167,8 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> {
     fn next_back(&mut self) -> Option<&'a mut [T]> {
         if self.finished { return None; }
 
-        match self.v.iter().rposition(|x| (self.pred)(x)) {
+        let pred = &mut self.pred;
+        match self.v.iter().rposition(|x| (*pred)(x)) {
             None => {
                 self.finished = true;
                 let tmp = mem::replace(&mut self.v, &mut []);
@@ -3340,7 +3341,7 @@ mod tests {
         assert_eq!(v.chunks(6).collect::<~[&[int]]>(), ~[&[1i,2,3,4,5]]);
 
         assert_eq!(v.chunks(2).rev().collect::<~[&[int]]>(), ~[&[5i], &[3,4], &[1,2]]);
-        let it = v.chunks(2);
+        let mut it = v.chunks(2);
         assert_eq!(it.indexable(), 3);
         assert_eq!(it.idx(0).unwrap(), &[1,2]);
         assert_eq!(it.idx(1).unwrap(), &[3,4]);
diff --git a/src/libstd/unstable/finally.rs b/src/libstd/unstable/finally.rs
index 96e52a4818e..3d00c0ac74a 100644
--- a/src/libstd/unstable/finally.rs
+++ b/src/libstd/unstable/finally.rs
@@ -145,7 +145,7 @@ fn test_fail() {
 
 #[test]
 fn test_retval() {
-    let closure: || -> int = || 10;
+    let mut closure: || -> int = || 10;
     let i = closure.finally(|| { });
     assert_eq!(i, 10);
 }
@@ -154,6 +154,6 @@ fn test_retval() {
 fn test_compact() {
     fn do_some_fallible_work() {}
     fn but_always_run_this_function() { }
-    do_some_fallible_work.finally(
-        but_always_run_this_function);
+    let mut f = do_some_fallible_work;
+    f.finally(but_always_run_this_function);
 }