---

yaml
---
r: 146017
b: refs/heads/try2
c: 1093730
h: refs/heads/master
i:
  146015: 9cd8a86
v: v3

Author: chris-morgan

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 3f240fedecf84f9bb614c52f5cc1335057008749
+refs/heads/try2: 1093730d721e64d71f0db18239714903d7f731b1
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/arc.rs

@@ -823,7 +823,7 @@ mod tests {
         do 5.times {
             let arc3 = arc.clone();
             let mut builder = task::task();
-            children.push(builder.future_result());
+            builder.future_result(|r| children.push(r));
             do builder.spawn {
                 do arc3.read |num| {
                     assert!(*num >= 0);

branches/try2/src/libextra/test.rs

@@ -870,12 +870,14 @@ pub fn run_test(force_ignore: bool,
                       testfn: ~fn()) {
         let testfn_cell = ::std::cell::Cell::new(testfn);
         do task::spawn {
+            let mut result_future = None; // task::future_result(builder);
+
             let mut task = task::task();
             task.unlinked();
-            let result_future = task.future_result();
+            task.future_result(|r| { result_future = Some(r) });
             task.spawn(testfn_cell.take());
 
-            let task_result = result_future.recv();
+            let task_result = result_future.unwrap().recv();
             let test_result = calc_result(&desc,
                                           task_result == task::Success);
             monitor_ch.send((desc.clone(), test_result));

branches/try2/src/libextra/url.rs

@@ -671,9 +671,13 @@ pub fn to_str(url: &Url) -> ~str {
     };
 
     let authority = if url.host.is_empty() {
+        // If port is Some, we're in a nonsensical situation. Too bad.
         ~""
     } else {
-        format!("//{}{}", user, url.host)
+        match url.port {
+            Some(ref port) => format!("//{}{}:{}", user, url.host, *port),
+            None => format!("//{}{}", user, url.host),
+        }
     };
 
     let query = if url.query.is_empty() {
@@ -895,6 +899,12 @@ mod tests {
         assert_eq!(from_str(url).unwrap().to_str(), url);
     }
 
+    #[test]
+    fn test_url_with_port_parse_and_format() {
+        let url = ~"http://rust-lang.org:80/doc";
+        assert_eq!(from_str(url).unwrap().to_str(), url);
+    }
+
     #[test]
     fn test_scheme_host_only_url_parse_and_format() {
         let url = ~"http://rust-lang.org";

branches/try2/src/libstd/result.rs

@@ -463,6 +463,7 @@ mod tests {
     use str::OwnedStr;
     use vec::ImmutableVector;
     use to_str::ToStr;
+    use fmt::Default;
 
     pub fn op1() -> Result<int, ~str> { Ok(666) }
     pub fn op2() -> Result<int, ~str> { Err(~"sadface") }

branches/try2/src/libstd/rt/task.rs

@@ -621,4 +621,29 @@ mod test {
             a.next = Some(b);
         }
     }
+
+    // XXX: This is a copy of test_future_result in std::task.
+    // It can be removed once the scheduler is turned on by default.
+    #[test]
+    fn future_result() {
+        do run_in_newsched_task {
+            use option::{Some, None};
+            use task::*;
+
+            let mut result = None;
+            let mut builder = task();
+            builder.future_result(|r| result = Some(r));
+            do builder.spawn {}
+            assert_eq!(result.unwrap().recv(), Success);
+
+            result = None;
+            let mut builder = task();
+            builder.future_result(|r| result = Some(r));
+            builder.unlinked();
+            do builder.spawn {
+                fail2!();
+            }
+            assert_eq!(result.unwrap().recv(), Failure);
+        }
+    }
 }

branches/try2/src/libstd/task/mod.rs

@@ -258,22 +258,24 @@ impl TaskBuilder {
         self.opts.indestructible = true;
     }
 
-    /// Get a future representing the exit status of the task.
-    ///
-    /// Taking the value of the future will block until the child task
-    /// terminates. The future result return value will be created *before* the task is
-    /// spawned; as such, do not invoke .get() on it directly;
-    /// rather, store it in an outer variable/list for later use.
-    ///
-    /// Note that the future returned by this function is only useful for
-    /// obtaining the value of the next task to be spawning with the
-    /// builder. If additional tasks are spawned with the same builder
-    /// then a new result future must be obtained prior to spawning each
-    /// task.
-    ///
-    /// # Failure
-    /// Fails if a future_result was already set for this task.
-    pub fn future_result(&mut self) -> Port<TaskResult> {
+    /**
+     * Get a future representing the exit status of the task.
+     *
+     * Taking the value of the future will block until the child task
+     * terminates. The future-receiving callback specified will be called
+     * *before* the task is spawned; as such, do not invoke .get() within the
+     * closure; rather, store it in an outer variable/list for later use.
+     *
+     * Note that the future returning by this function is only useful for
+     * obtaining the value of the next task to be spawning with the
+     * builder. If additional tasks are spawned with the same builder
+     * then a new result future must be obtained prior to spawning each
+     * task.
+     *
+     * # Failure
+     * Fails if a future_result was already set for this task.
+     */
+    pub fn future_result(&mut self, blk: &fn(v: Port<TaskResult>)) {
         // FIXME (#3725): Once linked failure and notification are
         // handled in the library, I can imagine implementing this by just
         // registering an arbitrary number of task::on_exit handlers and
@@ -286,10 +288,10 @@ impl TaskBuilder {
         // Construct the future and give it to the caller.
         let (notify_pipe_po, notify_pipe_ch) = stream::<TaskResult>();
 
+        blk(notify_pipe_po);
+
         // Reconfigure self to use a notify channel.
         self.opts.notify_chan = Some(notify_pipe_ch);
-
-        notify_pipe_po
     }
 
     /// Name the task-to-be. Currently the name is used for identification
@@ -396,14 +398,15 @@ impl TaskBuilder {
      */
     pub fn try<T:Send>(&mut self, f: ~fn() -> T) -> Result<T,()> {
         let (po, ch) = stream::<T>();
+        let mut result = None;
 
-        let result = self.future_result();
+        self.future_result(|r| { result = Some(r); });
 
         do self.spawn {
             ch.send(f());
         }
 
-        match result.recv() {
+        match result.unwrap().recv() {
             Success => result::Ok(po.recv()),
             Failure => result::Err(())
         }
@@ -1021,25 +1024,27 @@ fn test_add_wrapper() {
 
 #[test]
 fn test_future_result() {
+    let mut result = None;
     let mut builder = task();
-    let result = builder.future_result();
+    builder.future_result(|r| result = Some(r));
     do builder.spawn {}
-    assert_eq!(result.recv(), Success);
+    assert_eq!(result.unwrap().recv(), Success);
 
+    result = None;
     let mut builder = task();
-    let result = builder.future_result();
+    builder.future_result(|r| result = Some(r));
     builder.unlinked();
     do builder.spawn {
         fail2!();
     }
-    assert_eq!(result.recv(), Failure);
+    assert_eq!(result.unwrap().recv(), Failure);
 }
 
 #[test] #[should_fail]
 fn test_back_to_the_future_result() {
     let mut builder = task();
-    builder.future_result();
-    builder.future_result();
+    builder.future_result(util::ignore);
+    builder.future_result(util::ignore);
 }
 
 #[test]

branches/try2/src/libstd/unstable/sync.rs

@@ -580,29 +580,32 @@ mod tests {
         // Now try the same thing, but with the child task blocking.
         let x = Exclusive::new(~~"hello");
         let x2 = Cell::new(x.clone());
+        let mut res = None;
         let mut builder = task::task();
-        let res = builder.future_result();
+        builder.future_result(|r| res = Some(r));
         do builder.spawn {
             let x2 = x2.take();
             assert!(x2.unwrap() == ~~"hello");
         }
         // Have to get rid of our reference before blocking.
         util::ignore(x);
-        res.recv();
+        res.unwrap().recv();
     }
 
     #[test] #[should_fail]
     fn exclusive_new_unwrap_conflict() {
         let x = Exclusive::new(~~"hello");
         let x2 = Cell::new(x.clone());
+        let mut res = None;
         let mut builder = task::task();
-        let res = builder.future_result();
+        builder.future_result(|r| res = Some(r));
         do builder.spawn {
             let x2 = x2.take();
             assert!(x2.unwrap() == ~~"hello");
         }
         assert!(x.unwrap() == ~~"hello");
-        assert!(res.recv() == task::Success);
+        // See #4689 for why this can't be just "res.recv()".
+        assert!(res.unwrap().recv() == task::Success);
     }
 
     #[test]

branches/try2/src/test/bench/msgsend-pipes-shared.rs

@@ -67,7 +67,7 @@ fn run(args: &[~str]) {
     for _ in range(0u, workers) {
         let to_child = to_child.clone();
         let mut builder = task::task();
-        worker_results.push(builder.future_result());
+        builder.future_result(|r| worker_results.push(r));
         do builder.spawn {
             for _ in range(0u, size / workers) {
                 //error2!("worker {:?}: sending {:?} bytes", i, num_bytes);

branches/try2/src/test/bench/msgsend-pipes.rs

@@ -61,7 +61,7 @@ fn run(args: &[~str]) {
     for _ in range(0u, workers) {
         let to_child = to_child.clone();
         let mut builder = task::task();
-        worker_results.push(builder.future_result());
+        builder.future_result(|r| worker_results.push(r));
         do builder.spawn {
             for _ in range(0u, size / workers) {
                 //error2!("worker {:?}: sending {:?} bytes", i, num_bytes);

branches/try2/src/test/bench/shootout-pfib.rs

@@ -84,7 +84,7 @@ fn stress(num_tasks: int) {
     let mut results = ~[];
     for i in range(0, num_tasks) {
         let mut builder = task::task();
-        results.push(builder.future_result());
+        builder.future_result(|r| results.push(r));
         do builder.spawn {
             stress_task(i);
         }

branches/try2/src/test/bench/task-perf-linked-failure.rs

@@ -54,12 +54,13 @@ fn grandchild_group(num_tasks: uint) {
 }
 
 fn spawn_supervised_blocking(myname: &str, f: ~fn()) {
+    let mut res = None;
     let mut builder = task::task();
-    let res = builder.future_result();
+    builder.future_result(|r| res = Some(r));
     builder.supervised();
     builder.spawn(f);
     error2!("{} group waiting", myname);
-    let x = res.recv();
+    let x = res.unwrap().recv();
     assert_eq!(x, task::Success);
 }
 

branches/try2/src/test/run-pass/task-comm-12.rs

@@ -18,8 +18,9 @@ fn start(_task_number: int) { info2!("Started / Finished task."); }
 
 fn test00() {
     let i: int = 0;
+    let mut result = None;
     let mut builder = task::task();
-    let result = builder.future_result();
+    builder.future_result(|r| result = Some(r));
     do builder.spawn {
         start(i)
     }
@@ -32,7 +33,7 @@ fn test00() {
     }
 
     // Try joining tasks that have already finished.
-    result.recv();
+    result.unwrap().recv();
 
     info2!("Joined task.");
 }

branches/try2/src/test/run-pass/task-comm-3.rs

@@ -45,7 +45,7 @@ fn test00() {
     while i < number_of_tasks {
         let ch = ch.clone();
         let mut builder = task::task();
-        results.push(builder.future_result());
+        builder.future_result(|r| results.push(r));
         builder.spawn({
             let i = i;
             || test00_start(&ch, i, number_of_messages)

branches/try2/src/test/run-pass/task-comm-9.rs

@@ -28,8 +28,9 @@ fn test00() {
     let (p, ch) = comm::stream();
     let number_of_messages: int = 10;
 
+    let mut result = None;
     let mut builder = task::task();
-    let result = builder.future_result();
+    builder.future_result(|r| result = Some(r));
     do builder.spawn {
         test00_start(&ch, number_of_messages);
     }
@@ -41,7 +42,7 @@ fn test00() {
         i += 1;
     }
 
-    result.recv();
+    result.unwrap().recv();
 
     assert_eq!(sum, number_of_messages * (number_of_messages - 1) / 2);
 }

branches/try2/src/test/run-pass/yield.rs

@@ -12,15 +12,16 @@
 use std::task;
 
 pub fn main() {
+    let mut result = None;
     let mut builder = task::task();
-    let result = builder.future_result();
+    builder.future_result(|r| { result = Some(r); });
     builder.spawn(child);
     error2!("1");
     task::deschedule();
     error2!("2");
     task::deschedule();
     error2!("3");
-    result.recv();
+    result.unwrap().recv();
 }
 
 fn child() {

branches/try2/src/test/run-pass/yield1.rs

@@ -12,12 +12,13 @@
 use std::task;
 
 pub fn main() {
+    let mut result = None;
     let mut builder = task::task();
-    let result = builder.future_result();
+    builder.future_result(|r| { result = Some(r); });
     builder.spawn(child);
     error2!("1");
     task::deschedule();
-    result.recv();
+    result.unwrap().recv();
 }
 
 fn child() { error2!("2"); }