---

yaml
---
r: 187563
b: refs/heads/tmp
c: eceab29
h: refs/heads/master
i:
  187561: 91636ca
  187559: f302449
v: v3

Author: bombless

[refs]

@@ -34,5 +34,5 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: eb06c0ecd26081ee8795447184f47d453e3b3fca
+refs/heads/tmp: eceab2963d731544e9a13d25a224b6a6364c5eee
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/tmp/CONTRIBUTING.md

@@ -14,7 +14,7 @@ links to the major sections:
 If you have questions, please make a post on [internals.rust-lang.org][internals] or
 hop on [#rust-internals][pound-rust-internals].
 
-As a reminder, all contributors are expected to follow our [Code of Conduct][coc].
+As a reminder, all contributors are expected to follow our [Code of Conduct](coc).
 
 [pound-rust-internals]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
 [internals]: http://internals.rust-lang.org

branches/tmp/README.md

@@ -111,7 +111,7 @@ To contribute to Rust, please see [CONTRIBUTING.md](CONTRIBUTING.md).
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
 most popular channel is [#rust], a venue for general discussion about
-Rust, and a good place to ask for help,
+Rust, and a good place to ask for help.
 
 [IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
 [#rust]: irc://irc.mozilla.org/rust

branches/tmp/RELEASES.md

@@ -51,7 +51,7 @@ Version 1.0.0-alpha.2 (February 2015)
     * Abstract [OS-specific string types][osstr], `std::ff::{OsString,
       OsStr}`, provide strings in platform-specific encodings for easier
       interop with system APIs. [RFC][osstr-rfc].
-    * The `boxed::into_raw` and `Box::from_raw` functions [convert
+    * The `boxed::into_raw` and `Box::frow_raw` functions [convert
       between `Box<T>` and `*mut T`][boxraw], a common pattern for
       creating raw pointers.
 

branches/tmp/configure

@@ -374,12 +374,8 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=unknown-dragonfly
         ;;
 
-    Bitrig)
-        CFG_OSTYPE=unknown-bitrig
-        ;;
-
     OpenBSD)
-        CFG_OSTYPE=unknown-openbsd
+	CFG_OSTYPE=unknown-openbsd
        ;;
 
     Darwin)
@@ -751,13 +747,6 @@ then
     CFG_ENABLE_CLANG=1
 fi
 
-# Force bitrig to build with clang; gcc doesn't like us there
-if [ $CFG_OSTYPE = unknown-bitrig ]
-then
-    step_msg "on Bitrig, forcing use of clang"
-    CFG_ENABLE_CLANG=1
-fi
-
 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 then
     err "either clang or gcc is required"

branches/tmp/mk/cfg/x86_64-unknown-bitrig.mk

@@ -144,14 +144,14 @@ FIND_COMPILER = $(word 1,$(1:ccache=))
 define CFG_MAKE_TOOLCHAIN
   # Prepend the tools with their prefix if cross compiling
   ifneq ($(CFG_BUILD),$(1))
-       CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
-       CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
-       CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
-       AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-       RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
-           -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
-
-       RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
+	CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
+	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
+	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
+	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CC_$(1))) \
+	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
+
+	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
   endif
 
   CFG_COMPILE_C_$(1) = $$(CC_$(1)) \
@@ -179,19 +179,11 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On Bitrig, we need the relocation model to be PIC for everthing
-  ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
-    LLVM_MC_RELOCATION_MODEL="pic"
-  else
-    LLVM_MC_RELOCATION_MODEL="default"
-  endif
-
   # We're using llvm-mc as our assembler because it supports
   # .cfi pseudo-ops on mac
   CFG_ASSEMBLE_$(1)=$$(CPP_$(1)) -E $$(CFG_DEPEND_FLAGS) $$(2) | \
                     $$(LLVM_MC_$$(CFG_BUILD)) \
                     -assemble \
-                    -relocation-model=$$(LLVM_MC_RELOCATION_MODEL) \
                     -filetype=obj \
                     -triple=$(1) \
                     -o=$$(1)
@@ -200,7 +192,7 @@ define CFG_MAKE_TOOLCHAIN
   # For the ARM, AARCH64, MIPS and POWER crosses, use the toolchain assembler
   # FIXME: We should be able to use the LLVM assembler
   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-                   $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
+		    $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
 
   endif
 

branches/tmp/mk/platform.mk

@@ -268,7 +268,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         logfile: config.logfile.clone(),
         run_tests: true,
         run_benchmarks: true,
-        nocapture: env::var("RUST_TEST_NOCAPTURE").is_ok(),
+        nocapture: false,
         color: test::AutoColor,
     }
 }

branches/tmp/src/compiletest/compiletest.rs

@@ -58,7 +58,7 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(last_nonfollow_error: Option<uint>,
                   line_num: uint,
                   line: &str) -> Option<(WhichLine, ExpectedError)> {
-    let start = match line.find("//~") { Some(i) => i, None => return None };
+    let start = match line.find_str("//~") { Some(i) => i, None => return None };
     let (follow, adjusts) = if line.char_at(start + 3) == '|' {
         (true, 0)
     } else {

branches/tmp/src/compiletest/errors.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::env;
-
 use common::Config;
 use common;
 use util;
@@ -127,16 +125,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
         true
     });
 
-    for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_TASKS"] {
-        match env::var(key) {
-            Ok(val) =>
-                if exec_env.iter().find(|&&(ref x, _)| *x == key.to_string()).is_none() {
-                    exec_env.push((key.to_string(), val))
-                },
-            Err(..) => {}
-        }
-    }
-
     TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
@@ -342,7 +330,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 pub fn parse_name_value_directive(line: &str, directive: &str)
                                   -> Option<String> {
     let keycolon = format!("{}:", directive);
-    match line.find(&keycolon) {
+    match line.find_str(&keycolon) {
         Some(colon) => {
             let value = line[(colon + keycolon.len()) .. line.len()].to_string();
             debug!("{}: {}", directive, value);

branches/tmp/src/compiletest/header.rs

@@ -847,7 +847,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
             check_lines.iter().map(|s| {
                 s
                  .trim()
-                 .split("[...]")
+                 .split_str("[...]")
                  .map(|x| x.to_string())
                  .collect()
             }).collect();
@@ -866,7 +866,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                         None
                     }
                 } else {
-                    rest.find(frag)
+                    rest.find_str(frag)
                 };
                 match found {
                     None => {

branches/tmp/src/compiletest/runtest.rs

@@ -23,7 +23,6 @@ static OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("linux", "linux"),
     ("freebsd", "freebsd"),
     ("dragonfly", "dragonfly"),
-    ("bitrig", "bitrig"),
     ("openbsd", "openbsd"),
 ];
 

branches/tmp/src/compiletest/util.rs

@@ -426,33 +426,39 @@ use std::thread::Thread;
 fn main() {
     let mut numbers = vec![1, 2, 3];
 
-    let guards: Vec<_> = (0..3).map(|i| {
-        Thread::scoped(move || {
+    for i in 0..3 {
+        Thread::spawn(move || {
             for j in 0..3 { numbers[j] += 1 }
         });
-    }).collect();
+    }
 }
 ```
 
 It gives us this error:
 
 ```text
-7:29: 9:10 error: cannot move out of captured outer variable in an `FnMut` closure
-7         Thread::scoped(move || {
-8             for j in 0..3 { numbers[j] += 1 }
-9         });
+6:71 error: capture of moved value: `numbers`
+    for j in 0..3 { numbers[j] += 1 }
+                    ^~~~~~~
+7:50 note: `numbers` moved into closure environment here
+    spawn(move || {
+        for j in 0..3 { numbers[j] += 1 }
+    });
+6:79 error: cannot assign to immutable dereference (dereference is implicit, due to indexing)
+        for j in 0..3 { numbers[j] += 1 }
+                        ^~~~~~~~~~~~~~~
 ```
 
-It mentions that "captured outer variable in an `FnMut` closure".
-Because we declared the closure as a moving closure, and it referred
-to `numbers`, the closure will try to take ownership of the
-vector. But the closure itself is created in a loop, and hence we will
-actually create three closures, one for every iteration of the
-loop. This means that all three of those closures would try to own
-`numbers`, which is impossible -- `numbers` must have just one
-owner. Rust detects this and gives us the error: we claim that
-`numbers` has ownership, but our code tries to make three owners. This
-may cause a safety problem, so Rust disallows it.
+It mentions that "numbers moved into closure environment". Because we
+declared the closure as a moving closure, and it referred to
+`numbers`, the closure will try to take ownership of the vector. But
+the closure itself is created in a loop, and hence we will actually
+create three closures, one for every iteration of the loop. This means
+that all three of those closures would try to own `numbers`, which is
+impossible -- `numbers` must have just one owner. Rust detects this
+and gives us the error: we claim that `numbers` has ownership, but our
+code tries to make three owners. This may cause a safety problem, so
+Rust disallows it.
 
 What to do here? Rust has two types that helps us: `Arc<T>` and `Mutex<T>`.
 *Arc* stands for "atomically reference counted". In other words, an Arc will
@@ -474,14 +480,14 @@ use std::sync::{Arc,Mutex};
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
 
-    let guards: Vec<_> = (0..3).map(|i| {
+    for i in 0..3 {
         let number = numbers.clone();
-        Thread::scoped(move || {
+        Thread::spawn(move || {
             let mut array = number.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
         });
-    }).collect();
+    }
 }
 ```
 
@@ -510,10 +516,8 @@ numbers[1] is 3
 numbers[0] is 2
 ```
 
-Each time, we can get a slithtly different output because the threads
-are not quaranteed to run in any set order. If you get the same order
-every time it is because each of these threads are very small and
-complete too fast for their indeterminate behavior to surface.
+Each time, we get a slightly different output, because each thread works in a
+different order. You may not get the same output as this sample, even.
 
 The important part here is that the Rust compiler was able to use ownership to
 give us assurance _at compile time_ that we weren't doing something incorrect
@@ -535,13 +539,13 @@ safety check that makes this an error about moved values:
 use std::thread::Thread;
 
 fn main() {
-    let numbers = vec![1, 2, 3];
-    
-    let guards: Vec<_> = (0..3).map(|i| {
-        Thread::scoped(move || {
-            println!("{}", numbers[i]);
+    let vec = vec![1, 2, 3];
+
+    for i in 0..3 {
+        Thread::spawn(move || {
+            println!("{}", vec[i]);
         });
-    }).collect();
+    }
 }
 ```
 

branches/tmp/src/doc/intro.md

@@ -515,9 +515,6 @@ This last example is different because it is not possible to use the suffix
 syntax with a floating point literal ending in a period. `2.f64` would attempt
 to call a method named `f64` on `2`.
 
-The representation semantics of floating-point numbers are described in
-["Machine Types"](#machine-types).
-
 #### Boolean literals
 
 The two values of the boolean type are written `true` and `false`.
@@ -2191,8 +2188,8 @@ The following configurations must be defined by the implementation:
   `"unix"` or `"windows"`. The value of this configuration option is defined
   as a configuration itself, like `unix` or `windows`.
 * `target_os = "..."`. Operating system of the target, examples include
-  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
-  `"bitrig"` or `"openbsd"`.
+  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"` or
+  `"openbsd"`.
 * `target_word_size = "..."`. Target word size in bits. This is set to `"32"`
   for targets with 32-bit pointers, and likewise set to `"64"` for 64-bit
   pointers.

branches/tmp/src/doc/reference.md

@@ -12,7 +12,7 @@ Rust has two distinct terms that relate to the module system: *crate* and
 *module*. A crate is synonymous with a *library* or *package* in other
 languages. Hence "Cargo" as the name of Rust's package management tool: you
 ship your crates to others with Cargo. Crates can produce an executable or a
-library, depending on the project.
+shared library, depending on the project.
 
 Each crate has an implicit *root module* that contains the code for that crate.
 You can then define a tree of sub-modules under that root module. Modules allow

branches/tmp/src/doc/trpl/crates-and-modules.md

@@ -91,7 +91,7 @@ fn main() {
 ```
 
 You've seen this code before, when we talked about standard input. We
-import the `std::old_io` module with `use`, and then our `main` function contains
+import the `std::io` module with `use`, and then our `main` function contains
 our program's logic. We print a little message announcing the game, ask the
 user to input a guess, get their input, and then print it out.
 

branches/tmp/src/doc/trpl/guessing-game.md

@@ -34,20 +34,6 @@ if x == 5 {
 }
 ```
 
-If there is more than one case, use an `else if`:
-
-```rust
-let x = 5;
-
-if x == 5 {
-    println!("x is five!");
-} else if x == 6 {
-    println!("x is six!");
-} else {
-    println!("x is not five or six :(");
-}
-```
-
 This is all pretty standard. However, you can also do this: