---

yaml
---
r: 104559
b: refs/heads/try
c: 90f2d1d
h: refs/heads/master
i:
  104557: 1ad9869
  104555: b391fdd
  104551: 2dd1539
  104543: b3ee340
v: v3

Author: zslayton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: 86177dbbcf65be72c8d2a4c8bc2f5dc84f5ae65c
+refs/heads/try: 90f2d1d947b5882986e3c2c9e3cda2e959adea0d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.travis.yml

@@ -39,13 +39,10 @@ before_script:
 # manually disables bringing in these two libraries, but the stock LLVM was
 # apparently built with these options. We provide these options when building so
 # the `rustc` binary can successfully link.
-#
-# As a result of https://github.com/travis-ci/travis-ci/issues/1066, we run
-# everything in one large command instead of multiple commands.
-script: |
-  make tidy &&
-  RUSTFLAGS="-C link-args='-lffi -lncurses'" make -j4 rustc-stage1 &&
-  make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
+script:
+  - make tidy
+  - RUSTFLAGS="-C link-args='-lffi -lncurses'" make -j4 rustc-stage1
+  - make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
 
 env:
   - NO_BENCH=1

branches/try/configure

@@ -803,6 +803,7 @@ do
     make_dir $h/test/doc-guide-pointers
     make_dir $h/test/doc-guide-container
     make_dir $h/test/doc-guide-tasks
+    make_dir $h/test/doc-guide-conditions
     make_dir $h/test/doc-complement-cheatsheet
     make_dir $h/test/doc-rust
 done

branches/try/mk/crates.mk

@@ -65,18 +65,18 @@ DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
               collections time extra
 DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
                 test time
-DEPS_flate := std extra native:miniz
+DEPS_flate := std native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
-DEPS_serialize := std collections
+DEPS_serialize := std
 DEPS_term := std collections
 DEPS_semver := std
 DEPS_uuid := std serialize
 DEPS_sync := std
 DEPS_getopts := std
-DEPS_collections := std
+DEPS_collections := std serialize
 DEPS_fourcc := syntax std
-DEPS_num := std
+DEPS_num := std extra
 DEPS_test := std extra collections getopts serialize term
 DEPS_time := std serialize
 

branches/try/mk/main.mk

@@ -345,10 +345,10 @@ endif
 ifdef CFG_DISABLE_RPATH
 ifeq ($$(OSTYPE_$(3)),apple-darwin)
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
+      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(HLIB$(1)_H_$(3))"
 else
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
+      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(HLIB$(1)_H_$(3))"
 endif
 else
     RPATH_VAR$(1)_T_$(2)_H_$(3) :=

branches/try/mk/tests.mk

@@ -171,9 +171,7 @@ endif
 # Main test targets
 ######################################################################
 
-check: cleantmptestlogs cleantestlibs tidy check-notidy
-
-check-notidy: cleantmptestlogs cleantestlibs all check-stage2
+check: cleantestlibs cleantmptestlogs tidy all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 check-lite: cleantestlibs cleantmptestlogs \
@@ -708,9 +706,8 @@ check-stage$(1)-T-$(2)-H-$(3)-doc-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3)
 ifeq ($(2),$$(CFG_BUILD))
 $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4)): $$(DOCTESTDEP_$(1)_$(2)_$(3)_$(4))
 	@$$(call E, run doc-$(4) [$(2)])
-	$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3)) \
-		$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) --test \
-	    	$$(CRATEFILE_$(4)) --test-args "$$(TESTARGS)" && touch $$@
+	$$(Q)$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) --test \
+	    $$(CRATEFILE_$(4)) --test-args "$$(TESTARGS)" && touch $$@
 else
 $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4)):
 	touch $$@
@@ -937,8 +934,7 @@ $(3)/test/run-make/%-$(1)-T-$(2)-H-$(3).ok: \
 	    $(3)/test/run-make/$$* \
 	    "$$(CC_$(3)) $$(CFG_GCCISH_CFLAGS_$(3))" \
 	    $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
-	    "$$(TESTNAME)" \
-	    "$$(RPATH_VAR$(1)_T_$(2)_H_$(3))"
+	    "$$(TESTNAME)"
 	@touch $$@
 else
 # FIXME #11094 - The above rule doesn't work right for multiple targets

branches/try/src/README.md

@@ -10,21 +10,6 @@ Source layout:
 | `libgreen/`         | The M:N runtime library                                   |
 | `libnative/`        | The 1:1 runtime library                                   |
 | `libsyntax/`        | The Rust parser and pretty-printer                        |
-| `libcollections/`   | A collection of useful data structures and containers     |
-| `libnum/`           | Extended number support library (complex, rational, etc)  |
-| `libtest/`          | Rust's test-runner code                                   |
-| ------------------- | --------------------------------------------------------- |
-| `libarena/`         | The arena (a fast but limited) memory allocator           |
-| `libflate/`         | Simple compression library                                |
-| `libfourcc/`        | Data format identifier library                            |
-| `libgetopts/`       | Get command-line-options library                          |
-| `libglob/`          | Unix glob patterns library                                |
-| `libsemver/`        | Rust's semantic versioning library                        |
-| `libserialize/`     | Encode-Decode types library                               |
-| `libsync/`          | Concurrency mechanisms and primitives                     |
-| `libterm/`          | ANSI color library for terminals                          |
-| `libtime/`          | Time operations library                                   |
-| `libuuid/`          | UUID's handling code                                      |
 | ------------------- | --------------------------------------------------------- |
 | `rt/`               | The runtime system                                        |
 | `rt/rust_*.c`       | - Some of the runtime services                            |
@@ -46,13 +31,8 @@ Source layout:
 | ------------------- | --------------------------------------------------------- |
 | `librustdoc/`       | The Rust API documentation tool                           |
 | `libuv/`            | The libuv submodule                                       |
-| `librustuv/`        | Rust libuv support code                                   |
 | ------------------- | --------------------------------------------------------- |
 | `llvm/`             | The LLVM submodule                                        |
 | `rustllvm/`         | LLVM support code                                         |
 | ------------------- | --------------------------------------------------------- |
 | `etc/`              | Scripts, editors support, misc                            |
-
-
-NOTE: This list (especially the second part of the table which contains modules and libraries)
-is highly volatile and subject to change.

branches/try/src/compiletest/procsrv.rs

@@ -9,8 +9,9 @@
 // except according to those terms.
 
 use std::os;
+use std::run;
 use std::str;
-use std::io::process::{ProcessExit, Process, ProcessConfig, ProcessOutput};
+use std::io::process::ProcessExit;
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
@@ -35,26 +36,8 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
-fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
-    // Make sure we include the aux directory in the path
-    let aux_path = prog + ".libaux";
-
-    let mut env = os::env();
-    let var = if cfg!(target_os = "macos") {
-        "DYLD_LIBRARY_PATH"
-    } else {
-        "LD_LIBRARY_PATH"
-    };
-    let prev = match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
-        Some(i) => env.remove(i).unwrap().val1(),
-        None => ~"",
-    };
-    env.push((var.to_owned(), if prev.is_empty() {
-        lib_path + ":" + aux_path
-    } else {
-        lib_path + ":" + aux_path + ":" + prev
-    }));
-    return env;
+fn target_env(_lib_path: &str, _prog: &str) -> ~[(~str,~str)] {
+    os::env()
 }
 
 pub struct Result {status: ProcessExit, out: ~str, err: ~str}
@@ -66,19 +49,17 @@ pub fn run(lib_path: &str,
            input: Option<~str>) -> Option<Result> {
 
     let env = env + target_env(lib_path, prog);
-    let mut opt_process = Process::configure(ProcessConfig {
-        program: prog,
-        args: args,
-        env: Some(env.as_slice()),
-        .. ProcessConfig::new()
+    let mut opt_process = run::Process::new(prog, args, run::ProcessOptions {
+        env: Some(env),
+        .. run::ProcessOptions::new()
     });
 
     match opt_process {
         Ok(ref mut process) => {
             for input in input.iter() {
-                process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
+                process.input().write(input.as_bytes()).unwrap();
             }
-            let ProcessOutput { status, output, error } = process.wait_with_output();
+            let run::ProcessOutput { status, output, error } = process.finish_with_output();
 
             Some(Result {
                 status: status,
@@ -94,20 +75,18 @@ pub fn run_background(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
-           input: Option<~str>) -> Option<Process> {
+           input: Option<~str>) -> Option<run::Process> {
 
     let env = env + target_env(lib_path, prog);
-    let opt_process = Process::configure(ProcessConfig {
-        program: prog,
-        args: args,
-        env: Some(env.as_slice()),
-        .. ProcessConfig::new()
+    let opt_process = run::Process::new(prog, args, run::ProcessOptions {
+        env: Some(env),
+        .. run::ProcessOptions::new()
     });
 
     match opt_process {
         Ok(mut process) => {
             for input in input.iter() {
-                process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
+                process.input().write(input.as_bytes()).unwrap();
             }
 
             Some(process)

branches/try/src/compiletest/runtest.rs

@@ -360,7 +360,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                                stdout: out,
                                stderr: err,
                                cmdline: cmdline};
-            process.signal_kill().unwrap();
+            process.force_destroy().unwrap();
         }
 
         _=> {

branches/try/src/doc/index.md

@@ -19,6 +19,7 @@ li {list-style-type: none; }
 * [Foreign Function Interface](guide-ffi.html)
 * [Macros](guide-macros.html)
 * [Testing](guide-testing.html)
+* [Conditions](guide-conditions.html)
 * [Rust's Runtime](guide-runtime.html)
 
 # Libraries
@@ -42,7 +43,6 @@ li {list-style-type: none; }
 * [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 * [The `syntax` library, the Rust parser](syntax/index.html)
 * [The `term` terminal-handling library](term/index.html)
-* [The `test` library](test/index.html)
 * [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
 
 # Tooling

branches/try/src/doc/rust.md

@@ -875,16 +875,16 @@ An example of what will and will not work for `use` items:
 
 ~~~~
 # #[allow(unused_imports)];
-use foo::native::start;  // good: foo is at the root of the crate
+use foo::extra::json;    // good: foo is at the root of the crate
 use foo::baz::foobaz;    // good: foo is at the root of the crate
 
 mod foo {
-    extern crate native;
+    extern crate extra;
 
-    use foo::native::start; // good: foo is at crate root
-//  use native::start;      // bad:  native is not at the crate root
-    use self::baz::foobaz;  // good: self refers to module 'foo'
-    use foo::bar::foobar;   // good: foo is at crate root
+    use foo::extra::json;  // good: foo is at crate root
+//  use extra::json::*;    // bad:  extra is not at the crate root
+    use self::baz::foobaz; // good: self refers to module 'foo'
+    use foo::bar::foobar;  // good: foo is at crate root
 
     pub mod bar {
         pub fn foobar() { }

branches/try/src/doc/tutorial.md

@@ -1420,8 +1420,8 @@ bad, but often copies are expensive. So we’d like to define a function
 that takes the points by pointer. We can use references to do this:
 
 ~~~
-use std::num::sqrt;
 # struct Point { x: f64, y: f64 }
+# fn sqrt(f: f64) -> f64 { 0.0 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
@@ -1468,14 +1468,14 @@ For a more in-depth explanation of references and lifetimes, read the
 
 ## Freezing
 
-Lending an &-pointer to an object freezes it and prevents mutation—even if the object was declared as `mut`.
+Lending an immutable pointer to an object freezes it and prevents mutation.
 `Freeze` objects have freezing enforced statically at compile-time. An example
 of a non-`Freeze` type is [`RefCell<T>`][refcell].
 
 ~~~~
 let mut x = 5;
 {
-    let y = &x; // `x` is now frozen. It cannot be modified or re-assigned.
+    let y = &x; // `x` is now frozen, it cannot be modified
 }
 // `x` is now unfrozen again
 # x = 3;
@@ -2021,8 +2021,8 @@ C++ templates.
 
 ## Traits
 
-Within a generic function—that is, a function parameterized by a
-type parameter, say, `T`—the operations we can do on arguments of
+Within a generic function -- that is, a function parameterized by a
+type parameter, say, `T` -- the operations we can do on arguments of
 type `T` are quite limited.  After all, since we don't know what type
 `T` will be instantiated with, we can't safely modify or query values
 of type `T`.  This is where _traits_ come into play. Traits are Rust's
@@ -2519,7 +2519,7 @@ of type `ABC` can be randomly generated and converted to a string:
 #[deriving(Eq)]
 struct Circle { radius: f64 }
 
-#[deriving(Rand, Show)]
+#[deriving(Rand, ToStr)]
 enum ABC { A, B, C }
 ~~~
 
@@ -2786,11 +2786,11 @@ src/animals.rs
 
     src/mammals/humans.rs
     src/mammals/humans/mod.rs
-~~~
+~~
 
 If the animals file is `src/animals/mod.rs`, `rustc` will look for:
 
-~~~ {.notrust}
+~~ {.notrust}
 src/animals/mod.rs
     src/animals/fish.rs
     src/animals/fish/mod.rs

branches/try/src/etc/maketest.py

@@ -17,9 +17,6 @@
 os.putenv('CC', sys.argv[4])
 os.putenv('RUSTDOC', os.path.abspath(sys.argv[5]))
 filt = sys.argv[6]
-ldpath = sys.argv[7]
-if ldpath != '':
-    os.putenv(ldpath.split('=')[0], ldpath.split('=')[1])
 
 if not filt in sys.argv[1]:
     sys.exit(0)

branches/try/src/libarena/lib.rs

@@ -167,12 +167,13 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
 // is necessary in order to properly do cleanup if a failure occurs
 // during an initializer.
 #[inline]
-fn bitpack_tydesc_ptr(p: *TyDesc, is_done: bool) -> uint {
-    p as uint | (is_done as uint)
+unsafe fn bitpack_tydesc_ptr(p: *TyDesc, is_done: bool) -> uint {
+    let p_bits: uint = transmute(p);
+    p_bits | (is_done as uint)
 }
 #[inline]
-fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
-    ((p & !1) as *TyDesc, p & 1 == 1)
+unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
+    (transmute(p & !1), p & 1 == 1)
 }
 
 impl Arena {