---

yaml
---
r: 14395
b: refs/heads/try
c: 3c95fa2
h: refs/heads/master
i:
  14393: b8a08ec
  14391: e2f92c4
v: v3

Author: db48x

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 46018107474675ece9b7ef482d2ff1be1086d085
+refs/heads/try: 3c95fa22daf157d8e2d07b20e66f9888de60681a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/doc/tutorial.md

@@ -2375,10 +2375,10 @@ module `task`.  Let's begin with the simplest one, `task::spawn()`:
 
 ~~~~
 let some_value = 22;
-task::spawn {||
+let child_task = task::spawn {||
     std::io::println("This executes in the child task.");
     std::io::println(#fmt("%d", some_value));
-}
+};
 ~~~~
 
 The argument to `task::spawn()` is a [unique
@@ -2456,66 +2456,70 @@ let result = comm::recv(port);
 ## Creating a task with a bi-directional communication path
 
 A very common thing to do is to spawn a child task where the parent
-and child both need to exchange messages with each
-other. The function `task::spawn_listener()` supports this pattern. We'll look
-briefly at how it is used.
+and child both need to exchange messages with each other. The function
+`task::spawn_connected()` supports this pattern. We'll look briefly at
+how it is used.
 
-To see how `spawn_listener()` works, we will create a child task
+To see how `spawn_connected()` works, we will create a child task
 which receives `uint` messages, converts them to a string, and sends
 the string in response.  The child terminates when `0` is received.
 Here is the function which implements the child task:
 
 ~~~~
-fn stringifier(from_parent: comm::port<uint>,
-               to_parent: comm::chan<str>) {
+fn stringifier(from_par: comm::port<uint>,
+               to_par: comm::chan<str>) {
     let value: uint;
     do {
-        value = comm::recv(from_parent);
-        comm::send(to_parent, uint::to_str(value, 10u));
+        value = comm::recv(from_par);
+        comm::send(to_par, uint::to_str(value, 10u));
     } while value != 0u;
 }
 
 ~~~~
-
 You can see that the function takes two parameters.  The first is a
 port used to receive messages from the parent, and the second is a
 channel used to send messages to the parent.  The body itself simply
 loops, reading from the `from_par` port and then sending its response
 to the `to_par` channel.  The actual response itself is simply the
 strified version of the received value, `uint::to_str(value)`.
- 
-Here is the code for the parent task:
 
+Here is the code for the parent task:
 ~~~~
-# fn stringifier(from_parent: comm::port<uint>,
-#                to_parent: comm::chan<str>) {
-#     comm::send(to_parent, "22");
-#     comm::send(to_parent, "23");
-#     comm::send(to_parent, "0");
+# fn stringifier(from_par: comm::port<uint>,
+#                to_par: comm::chan<str>) {
+#     comm::send(to_par, "22");
+#     comm::send(to_par, "23");
+#     comm::send(to_par, "0");
 # }
 fn main() {
-    let from_child = comm::port();
-    let to_parent = comm::chan(from_child);
-    let to_child = task::spawn_listener {|from_parent|
-        stringifier(from_parent, to_parent);
-    };
-    comm::send(to_child, 22u);
-    assert comm::recv(from_child) == "22";
-    comm::send(to_child, 23u);
-    assert comm::recv(from_child) == "23";
-    comm::send(to_child, 0u);
-    assert comm::recv(from_child) == "0";
-}
-~~~~
-
-The parent first sets up a port to receive data from and a channel
-that the child can use to send data to that port. The call to
-`spawn_listener()` will spawn the child task, providing it with a port
-on which to receive data from its parent, and returning to the parent
-the associated channel. Finally, the closure passed to
-`spawn_listener()` that forms the body of the child task captures the
-`to_parent` channel in its environment, so both parent and child
-can send and receive data to and from the other.
+    let t = task::spawn_connected(stringifier);
+    comm::send(t.to_child, 22u);
+    assert comm::recv(t.from_child) == "22";
+    comm::send(t.to_child, 23u);
+    assert comm::recv(t.from_child) == "23";
+    comm::send(t.to_child, 0u);
+    assert comm::recv(t.from_child) == "0";
+}
+~~~~
+
+The call to `spawn_connected()` on the first line will instantiate the
+various ports and channels and startup the child task.  The returned
+value, `t`, is a record of type `task::connected_task<uint,str>`.  In
+addition to the task id of the child, this record defines two fields,
+`from_child` and `to_child`, which contain the port and channel
+respectively for communicating with the child.  Those fields are used
+here to send and receive three messages from the child task.
+
+## Joining a task
+
+The function `spawn_joinable()` is used to spawn a task that can later
+be joined. This is implemented by having the child task send a message
+when it has completed (either successfully or by failing). Therefore,
+`spawn_joinable()` returns a structure containing both the task ID and
+the port where this message will be sent---this structure type is
+called `task::joinable_task`. The structure can be passed to
+`task::join()`, which simply blocks on the port, waiting to receive
+the message from the child task.
 
 ## The supervisor relationship
 

branches/try/mk/tests.mk

@@ -104,7 +104,7 @@ endif
 # Extracting tests for docs
 ######################################################################
 
-EXTRACT_TESTS := $(CFG_PYTHON) $(S)src/etc/extract-tests.py
+EXTRACT_TESTS := "$(CFG_PYTHON)" $(S)src/etc/extract-tests.py
 
 define DEF_DOC_TEST_HOST
 

branches/try/src/cargo/cargo.rs

@@ -6,7 +6,7 @@ use std;
 import rustc::syntax::{ast, codemap};
 import rustc::syntax::parse::parser;
 import rustc::util::filesearch::{get_cargo_root, get_cargo_root_nearest,
-                                 get_cargo_sysroot, libdir};
+                                 get_cargo_sysroot};
 import rustc::driver::diagnostic;
 
 import std::fs;
@@ -346,35 +346,39 @@ fn build_cargo_options(argv: [str]) -> options {
     };
 
     let test = opt_present(match, "test");
-    let G = opt_present(match, "G");
-    let g = opt_present(match, "g");
-    let m = opt_present(match, "mode");
-    let is_install = vec::len(match.free) > 1u && match.free[1] == "install";
-
-    if G && g { fail "-G and -g both provided"; }
-    if g && m { fail "--mode and -g both provided"; }
-    if G && m { fail "--mode and -G both provided"; }
-
-    let mode = if is_install {
-        if G { system_mode }
-        else if g { user_mode }
-        else if m {
-            alt getopts::opt_str(match, "mode") {
-                "system" { system_mode }
-                "user" { user_mode }
-                "local" { local_mode }
-                _ { fail "argument to `mode` must be one of `system`" +
-                    ", `user`, or `local`";
-                }
+    let mode = if opt_present(match, "G") {
+        if opt_present(match, "mode") { fail "--mode and -G both provided"; }
+        if opt_present(match, "g") { fail "-G and -g both provided"; }
+        system_mode
+    } else if opt_present(match, "g") {
+        if opt_present(match, "mode") { fail "--mode and -g both provided"; }
+        if opt_present(match, "G") { fail "-G and -g both provided"; }
+        user_mode
+    } else if opt_present(match, "mode") {
+        alt getopts::opt_str(match, "mode") {
+            "system" { system_mode }
+            "user" { user_mode }
+            "local" { local_mode }
+            _ { fail "argument to `mode` must be one of `system`" +
+                ", `user`, or `normal`";
             }
-        } else { local_mode }
-    } else { system_mode };
+        }
+    } else {
+        local_mode
+    };
+
+    if mode == system_mode {
+        // FIXME: Per discussion on #1760, we need to think about how
+        // system mode works. It should install files to the normal
+        // sysroot paths, but it also needsd an area to place various
+        // cargo configuration and work files.
+        fail "system mode does not exist yet";
+    }
 
     {test: test, mode: mode, free: match.free}
 }
 
 fn configure(opts: options) -> cargo {
-    let syscargo = result::get(get_cargo_sysroot());
     let get_cargo_dir = alt opts.mode {
         system_mode { get_cargo_sysroot }
         user_mode { get_cargo_root }
@@ -387,15 +391,15 @@ fn configure(opts: options) -> cargo {
     };
 
     let sources = map::new_str_hash::<source>();
-    try_parse_sources(fs::connect(syscargo, "sources.json"), sources);
-    try_parse_sources(fs::connect(syscargo, "local-sources.json"), sources);
+    try_parse_sources(fs::connect(p, "sources.json"), sources);
+    try_parse_sources(fs::connect(p, "local-sources.json"), sources);
     let c = {
         pgp: pgp::supported(),
         root: p,
         bindir: fs::connect(p, "bin"),
         libdir: fs::connect(p, "lib"),
         workdir: fs::connect(p, "work"),
-        sourcedir: fs::connect(syscargo, "sources"),
+        sourcedir: fs::connect(p, "sources"),
         sources: sources,
         opts: opts
     };
@@ -467,31 +471,10 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
             #debug("  bin: %s", ct);
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);
-            if c.opts.mode == system_mode {
-                install_one_crate_to_sysroot(ct, "bin");
-            }
         } else {
             #debug("  lib: %s", ct);
             run::run_program("cp", [ct, c.libdir]);
-            if c.opts.mode == system_mode {
-                install_one_crate_to_sysroot(ct, libdir());
-            }
-        }
-    }
-}
-
-fn install_one_crate_to_sysroot(ct: str, target: str) {
-    alt os::get_exe_path() {
-        some(_path) {
-            let path = [_path, "..", target];
-            check vec::is_not_empty(path);
-            let target_dir = fs::normalize(fs::connect_many(path));
-            let p = run::program_output("cp", [ct, target_dir]);
-            if p.status != 0 {
-                warn(#fmt["Copying %s to %s is failed", ct, target_dir]);
-            }
         }
-        none { }
     }
 }
 
@@ -848,25 +831,23 @@ fn cmd_usage() {
           "
 
     init                                          Set up .cargo
-    install [options] [source/]package-name       Install by name
-    install [options] uuid:[source/]package-uuid  Install by uuid
+    install [--test] [source/]package-name        Install by name
+    install [--test] uuid:[source/]package-uuid   Install by uuid
     list [source]                                 List packages
     search <name | '*'> [tags...]                 Search packages
     sync                                          Sync all sources
     usage                                         This
 
 Options:
 
-  cargo install
-
     --mode=[system,user,local]   change mode as (system/user/local)
     -g                           equivalent to --mode=user
     -G                           equivalent to --mode=system
 
 NOTE:
-\"cargo install\" installs bin/libs to local-level .cargo by default.
-To install them into user-level .cargo,  use option -g/--mode=user.
-To install them into bin/lib on sysroot, use option -G/--mode=system.
+This command creates/uses local-level .cargo by default.
+To create/use user-level .cargo, use option -g/--mode=user.
+To create/use system-level .cargo, use option -G/--mode=system.
 ");
 }
 

branches/try/src/comp/driver/rustc.rs

@@ -143,6 +143,8 @@ fn monitor(f: fn~(diagnostic::emitter)) {
 
     alt task::try  {||
 
+        task::unsupervise();
+
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
         let demitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>,