---

yaml
---
r: 102137
b: refs/heads/master
c: abde5ed
h: refs/heads/master
i:
  102135: 70906ae
v: v3

Author: huonw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 994b48cf5282339150157de1f6eb749102359649
+refs/heads/master: abde5ed0118a00dea07511f12bfab9e999223b62
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/.travis.yml

@@ -604,7 +604,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-5]svn|3.[2-5])
+        (3.[2-4]svn|3.[2-4])
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
@@ -626,7 +626,7 @@ then
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* )
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

trunk/configure

@@ -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_term := std collections
+DEPS_serialize := std
+DEPS_term := std
 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
 

trunk/mk/crates.mk

@@ -218,12 +218,8 @@ LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt llvm-extract
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples
 # separated by Z. This defines new ones with the expected format.
-ifeq ($$(CFG_LLVM_ROOT),)
 CFG_LLVM_BUILD_DIR_$(1):=$$(CFG_LLVM_BUILD_DIR_$(subst -,_,$(1)))
 CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_INST_DIR_$(subst -,_,$(1)))
-else
-CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_ROOT)
-endif
 
 # Any rules that depend on LLVM should depend on LLVM_CONFIG
 LLVM_CONFIG_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-config$$(X_$(1))

trunk/mk/main.mk

@@ -16,7 +16,7 @@
 #
 # It requires the following variables to be set:
 #
-#   PREPARE_HOST - the host triple
+#   PREPARE_HOST - the host triple 
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
@@ -172,10 +172,7 @@ prepare-target-$(2)-host-$(3)-$(1): \
         $$(if $$(findstring $(2),$$(CFG_HOST)), \
           $$(foreach crate,$$(HOST_CRATES), \
             $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)),)
-# Only install if this host and target combo is being prepared. Also be sure to
-# *not* install the rlibs for host crates because there's no need to statically
-# link against most of them. They just produce a large amount of extra size
-# bloat.
+# Only install if this host and target combo is being prepared
 	$$(if $$(findstring $(1), $$(PREPARE_STAGE)),\
       $$(if $$(findstring $(2), $$(PREPARE_TARGETS)),\
         $$(if $$(findstring $(3), $$(PREPARE_HOST)),\
@@ -185,7 +182,8 @@ prepare-target-$(2)-host-$(3)-$(1): \
             $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate))))\
           $$(if $$(findstring $(2),$$(CFG_HOST)),\
             $$(foreach crate,$$(HOST_CRATES),\
-              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))),)\
+              $$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))\
+              $$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))),)\
           $$(call PREPARE_LIB,libmorestack.a) \
           $$(call PREPARE_LIB,libcompiler-rt.a),),),)
 endef

trunk/mk/prepare.mk

@@ -171,7 +171,9 @@ endif
 # Main test targets
 ######################################################################
 
-check: cleantestlibs cleantmptestlogs tidy all check-stage2
+check: cleantmptestlogs cleantestlibs tidy check-notidy
+
+check-notidy: cleantmptestlogs cleantestlibs all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 check-lite: cleantestlibs cleantmptestlogs \

trunk/mk/tests.mk

@@ -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)] {
@@ -48,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,
@@ -76,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)

trunk/src/compiletest/procsrv.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();
         }
 
         _=> {

trunk/src/compiletest/runtest.rs

@@ -211,7 +211,7 @@ Description            C signature                                    Equivalent
 ---------------------- ---------------------------------------------- ------------------------------------------
 no parameters          `void foo(void);`                              `fn foo();`
 return value           `int foo(void);`                               `fn foo() -> c_int;`
-function parameters    `void foo(int x, int y);`                      `fn foo(x: c_int, y: c_int);`
+function parameters    `void foo(int x, int y);`                      `fn foo(x: int, y: int);`
 in-out pointers        `void foo(const int* in_ptr, int* out_ptr);`   `fn foo(in_ptr: *c_int, out_ptr: *mut c_int);`
 
 Note: The Rust signatures should be wrapped in an `extern "ABI" { ... }` block.

trunk/src/doc/complement-cheatsheet.md

@@ -38,7 +38,7 @@ order.
 Each `HashMap` instance has a random 128-bit key to use with a keyed hash,
 making the order of a set of keys in a given hash table randomized. Rust
 provides a [SipHash](https://131002.net/siphash/) implementation for any type
-implementing the `Hash` trait.
+implementing the `IterBytes` trait.
 
 ## Double-ended queues
 
@@ -186,12 +186,12 @@ let mut calls = 0;
     let it = xs.iter().scan((), |_, x| {
         calls += 1;
         if *x < 3 { Some(x) } else { None }});
-
+        
     // the iterator will only yield 1 and 2 before returning None
     // If we were to call it 5 times, calls would end up as 5, despite
     // only 2 values being yielded (and therefore 3 unique calls being
     // made). The fuse() adaptor can fix this.
-
+    
     let mut it = it.fuse();
     it.next();
     it.next();

trunk/src/doc/guide-container.md

@@ -4421,15 +4421,15 @@ msgstr ""
 #, fuzzy
 #| msgid ""
 #| "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
+#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
 #| "`Zero`, and `ToStr`."
 msgid ""
 "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
 "`Default`, `Zero`, and `ToStr`."
 msgstr ""
 "実装を自動的に導出可能なトレイトは、 `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, `Zero`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, `Zero`, "
 "および `ToStr` です。."
 
 #. type: Plain text

trunk/src/doc/po/ja/tutorial.md.po

@@ -467,7 +467,7 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# struct HashMap<K, V>;
+# use std::hashmap::HashMap;
 # fn f() {
 # fn id<T>(t: T) -> T { t }
 type T = HashMap<int,~str>;  // Type arguments used in a type expression
@@ -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() { }
@@ -2035,7 +2035,7 @@ Supported traits for `deriving` are:
 * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `serialize`.
 * `Clone` and `DeepClone`, to perform (deep) copies.
-* `Hash`, to iterate over the bytes in a data type.
+* `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `Default`, to create an empty instance of a data type.
 * `Zero`, to create an zero instance of a numeric data type.

trunk/src/doc/rust.md

@@ -1026,7 +1026,7 @@ type was invalid because the size was infinite!
 
 An *owned box* (`~`) uses a dynamic memory allocation to provide the invariant
 of always being the size of a pointer, regardless of the contained type. This
-can be leveraged to create a valid `List` definition:
+can be leverage to create a valid `List` definition:
 
 ~~~
 enum List {
@@ -1977,8 +1977,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-extern crate collections;
-type Set<T> = collections::HashMap<T, ()>;
+use std::hashmap::HashMap;
+type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]
@@ -1988,7 +1988,6 @@ enum Option<T> {
     Some(T),
     None
 }
-# fn main() {}
 ~~~~
 
 These declarations can be instantiated to valid types like `Set<int>`,
@@ -2519,13 +2518,13 @@ 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 }
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
 `TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
-`Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
+`IterBytes`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system
 

trunk/src/doc/tutorial.md

@@ -55,8 +55,6 @@ def scrub(b):
 #[crate_id=\"run_pass_stage2#0.1\"];
 #[feature(globs, macro_rules, struct_variant, managed_boxes)];
 #[allow(warnings)];
-extern crate collections;
-extern crate extra;
 """
 )
 for t in stage2_tests:

trunk/src/etc/combine-tests.py

@@ -119,8 +119,7 @@ def write_file(name, string):
                               ('Clone', [], 1), ('DeepClone', ['Clone'], 1),
                               ('Eq', [], 2), ('Ord', [], 8),
                               ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1),
-                              ('Show', [], 1),
-                              ('Hash', [], 1)]:
+                              ('Show', [], 1)]:
     traits[trait] = (ALL, supers, errs)
 
 for (trait, (types, super_traits, error_count)) in traits.items():

trunk/src/etc/generate-deriving-span-tests.py

@@ -93,6 +93,7 @@ syn keyword rustTrait GenericPath Path PosixPath WindowsPath
 syn keyword rustTrait RawPtr
 syn keyword rustTrait Buffer Writer Reader Seek
 syn keyword rustTrait Str StrVector StrSlice OwnedStr IntoMaybeOwned
+syn keyword rustTrait IterBytes
 syn keyword rustTrait ToStr IntoStr
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8