---

yaml
---
r: 58223
b: refs/heads/auto
c: bba0680
h: refs/heads/master
i:
  58221: 906881f
  58219: a901bfc
  58215: 6a1c4b7
  58207: 59e79b5
v: v3

Author: pcwalton

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 92d2ec4d32c7f7722569b1463cba31c6402f7513
+refs/heads/auto: bba0680cb0801bc52d2abfc87bbf0885dc0355f8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libstd/future.rs

@@ -29,7 +29,7 @@ use core::task;
 
 #[doc = "The future type"]
 pub struct Future<A> {
-    priv mut state: FutureState<A>,
+    priv state: FutureState<A>,
 }
 
 // FIXME(#2829) -- futures should not be copyable, because they close
@@ -47,33 +47,68 @@ priv enum FutureState<A> {
 
 /// Methods on the `future` type
 pub impl<A:Copy> Future<A> {
-    fn get(&self) -> A {
+    fn get(&mut self) -> A {
         //! Get the value of the future
         *(self.get_ref())
     }
 }
 
 pub impl<A> Future<A> {
+    #[cfg(stage0)]
     fn get_ref<'a>(&'a self) -> &'a A {
         /*!
         * Executes the future's closure and then returns a borrowed
         * pointer to the result.  The borrowed pointer lasts as long as
         * the future.
         */
         unsafe {
-            match self.state {
-                Forced(ref mut v) => { return cast::transmute(v); }
-                Evaluating => fail!(~"Recursive forcing of future!"),
-                Pending(_) => {}
+            {
+                match self.state {
+                    Forced(ref mut v) => { return cast::transmute(v); }
+                    Evaluating => fail!(~"Recursive forcing of future!"),
+                    Pending(_) => {}
+                }
+            }
+            {
+                let mut state = Evaluating;
+                self.state <-> state;
+                match state {
+                    Forced(_) | Evaluating => fail!(~"Logic error."),
+                    Pending(f) => {
+                        self.state = Forced(f());
+                        cast::transmute(self.get_ref())
+                    }
+                }
             }
+        }
+    }
 
-            let mut state = Evaluating;
-            self.state <-> state;
-            match state {
-                Forced(_) | Evaluating => fail!(~"Logic error."),
-                Pending(f) => {
-                    self.state = Forced(f());
-                    self.get_ref()
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn get_ref<'a>(&'a mut self) -> &'a A {
+        /*!
+        * Executes the future's closure and then returns a borrowed
+        * pointer to the result.  The borrowed pointer lasts as long as
+        * the future.
+        */
+        unsafe {
+            {
+                match self.state {
+                    Forced(ref mut v) => { return cast::transmute(v); }
+                    Evaluating => fail!(~"Recursive forcing of future!"),
+                    Pending(_) => {}
+                }
+            }
+            {
+                let mut state = Evaluating;
+                self.state <-> state;
+                match state {
+                    Forced(_) | Evaluating => fail!(~"Logic error."),
+                    Pending(f) => {
+                        self.state = Forced(f());
+                        cast::transmute(self.get_ref())
+                    }
                 }
             }
         }
@@ -150,54 +185,54 @@ mod test {
 
     #[test]
     fn test_from_value() {
-        let f = from_value(~"snail");
+        let mut f = from_value(~"snail");
         assert!(f.get() == ~"snail");
     }
 
     #[test]
     fn test_from_port() {
         let (po, ch) = oneshot();
         send_one(ch, ~"whale");
-        let f = from_port(po);
+        let mut f = from_port(po);
         assert!(f.get() == ~"whale");
     }
 
     #[test]
     fn test_from_fn() {
-        let f = from_fn(|| ~"brail");
+        let mut f = from_fn(|| ~"brail");
         assert!(f.get() == ~"brail");
     }
 
     #[test]
     fn test_interface_get() {
-        let f = from_value(~"fail");
+        let mut f = from_value(~"fail");
         assert!(f.get() == ~"fail");
     }
 
     #[test]
     fn test_get_ref_method() {
-        let f = from_value(22);
+        let mut f = from_value(22);
         assert!(*f.get_ref() == 22);
     }
 
     #[test]
     fn test_spawn() {
-        let f = spawn(|| ~"bale");
+        let mut f = spawn(|| ~"bale");
         assert!(f.get() == ~"bale");
     }
 
     #[test]
     #[should_fail]
     #[ignore(cfg(target_os = "win32"))]
     fn test_futurefail() {
-        let f = spawn(|| fail!());
+        let mut f = spawn(|| fail!());
         let _x: ~str = f.get();
     }
 
     #[test]
     fn test_sendable_future() {
         let expected = ~"schlorf";
-        let f = do spawn { copy expected };
+        let mut f = do spawn { copy expected };
         do task::spawn || {
             let actual = f.get();
             assert!(actual == expected);

branches/auto/src/libstd/par.rs

@@ -73,10 +73,10 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
         info!("num_tasks: %?", (num_tasks, futures.len()));
         assert!((num_tasks == futures.len()));
 
-        let r = do futures.map() |ys| {
+        let r = do vec::map_consume(futures) |ys| {
+            let mut ys = ys;
             ys.get()
         };
-        assert!((r.len() == futures.len()));
         r
     }
 }