---

yaml
---
r: 146019
b: refs/heads/try2
c: 0ae9e47
h: refs/heads/master
i:
  146017: 79a1984
  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: a1848bc755411285afb15f2453df7567e10ebc04
+refs/heads/try2: 0ae9e476afb3647f7d71498795165e0e7fd85f02
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/etc/vim/syntax/rust.vim

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2013 Sep 4
+" Last Change:  2013 Oct 19
 
 if version < 600
   syntax clear
@@ -61,6 +61,7 @@ syn keyword   rustEnumVariant Ok Err
 " Functions {{{3
 "syn keyword rustFunction print println
 "syn keyword rustFunction range
+"syn keyword rustFunction from_str
 
 " Types and traits {{{3
 syn keyword rustTrait ToCStr
@@ -79,22 +80,23 @@ syn keyword rustTrait Orderable Signed Unsigned Round
 syn keyword rustTrait Algebraic Trigonometric Exponential Hyperbolic
 syn keyword rustTrait Integer Fractional Real RealExt
 syn keyword rustTrait Bitwise BitCount Bounded
-syn keyword rustTrait Primitive Int Float ToStrRadix
+syn keyword rustTrait Primitive Int Float ToStrRadix ToPrimitive FromPrimitive
 syn keyword rustTrait GenericPath
 syn keyword rustTrait Path
 syn keyword rustTrait PosixPath
 syn keyword rustTrait WindowsPath
 syn keyword rustTrait RawPtr
 syn keyword rustTrait Ascii AsciiCast OwnedAsciiCast AsciiStr ToBytesConsume
+syn keyword rustTrait SendStr SendStrOwned SendStrStatic IntoSendStr
 syn keyword rustTrait Str StrVector StrSlice OwnedStr
 syn keyword rustTrait FromStr
 syn keyword rustTrait IterBytes
 syn keyword rustTrait ToStr ToStrConsume
 syn keyword rustTrait CopyableTuple ImmutableTuple
-syn keyword rustTrait CloneableTuple1 ImmutableTuple1
-syn keyword rustTrait CloneableTuple2 CloneableTuple3 CloneableTuple4 CloneableTuple5
-syn keyword rustTrait CloneableTuple6 CloneableTuple7 CloneableTuple8 CloneableTuple9
-syn keyword rustTrait CloneableTuple10 CloneableTuple11 CloneableTuple12
+syn keyword rustTrait Tuple1 ImmutableTuple1
+syn keyword rustTrait Tuple2 Tuple3 Tuple4 Tuple5
+syn keyword rustTrait Tuple6 Tuple7 Tuple8 Tuple9
+syn keyword rustTrait Tuple10 Tuple11 Tuple12
 syn keyword rustTrait ImmutableTuple2 ImmutableTuple3 ImmutableTuple4 ImmutableTuple5
 syn keyword rustTrait ImmutableTuple6 ImmutableTuple7 ImmutableTuple8 ImmutableTuple9
 syn keyword rustTrait ImmutableTuple10 ImmutableTuple11 ImmutableTuple12

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,13 +671,9 @@ 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 {
-        match url.port {
-            Some(ref port) => format!("//{}{}:{}", user, url.host, *port),
-            None => format!("//{}{}", user, url.host),
-        }
+        format!("//{}{}", user, url.host)
     };
 
     let query = if url.query.is_empty() {
@@ -899,12 +895,6 @@ 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);
 }