---

yaml
---
r: 193995
b: refs/heads/beta
c: e3cde97
h: refs/heads/master
i:
  193993: e73c529
  193991: 8c17fce
v: v3

Author: farcaller

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: c785e7e2a1fd86f5600a49c27ba6ac01a22ca7de
+refs/heads/beta: e3cde9783b33ed4decd467602ff3d47505eadab5
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/Makefile.in

@@ -97,7 +97,12 @@
 #     make check-stage1-rpass TESTNAME=my-shiny-new-test
 #
 #     // Having trouble figuring out which test is failing? Turn off parallel tests
-#     make check-stage1-std RUST_TEST_THREADS=1
+#     make check-stage1-std RUST_TEST_TASKS=1
+#
+# This is hardly all there is to know of The Rust Build System's
+# mysteries. The tale continues on the wiki[1].
+#
+# [1]: https://github.com/rust-lang/rust/wiki/Note-testsuite
 #
 # If you really feel like getting your hands dirty, then:
 #

branches/beta/src/compiletest/compiletest.rs

@@ -224,15 +224,15 @@ pub fn run_tests(config: &Config) {
         // android debug-info test uses remote debugger
         // so, we test 1 task at once.
         // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        env::set_var("RUST_TEST_THREADS","1");
+        env::set_var("RUST_TEST_TASKS","1");
     }
 
     match config.mode {
         DebugInfoLldb => {
             // Some older versions of LLDB seem to have problems with multiple
             // instances running in parallel, so only run one test task at a
             // time.
-            env::set_var("RUST_TEST_THREADS", "1");
+            env::set_var("RUST_TEST_TASKS", "1");
         }
         _ => { /* proceed */ }
     }

branches/beta/src/compiletest/header.rs

@@ -131,7 +131,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         true
     });
 
-    for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
+    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() {

branches/beta/src/doc/trpl/pointers.md

@@ -561,40 +561,38 @@ fn main() {
 In this case, Rust knows that `x` is being *borrowed* by the `add_one()`
 function, and since it's only reading the value, allows it.
 
-We can borrow `x` as read-only multiple times, even simultaneously:
+We can borrow `x` multiple times, as long as it's not simultaneous:
 
 ```{rust}
-fn add(x: &i32, y: &i32) -> i32 {
-    *x + *y
+fn add_one(x: &i32) -> i32 {
+    *x + 1
 }
 
 fn main() {
     let x = Box::new(5);
 
-    println!("{}", add(&x, &x));
-    println!("{}", add(&x, &x));
+    println!("{}", add_one(&*x));
+    println!("{}", add_one(&*x));
+    println!("{}", add_one(&*x));
 }
 ```
 
-We can mutably borrow `x` multiple times, but only if x itself is mutable, and
-it may not be *simultaneously* borrowed: 
+Or as long as it's not a mutable borrow. This will error:
 
 ```{rust,ignore}
-fn increment(x: &mut i32) {
-    *x += 1;
+fn add_one(x: &mut i32) -> i32 {
+    *x + 1
 }
 
 fn main() {
-    // If variable x is not "mut", this will not compile
-    let mut x = Box::new(5);
+    let x = Box::new(5);
 
-    increment(&mut x);
-    increment(&mut x);
-    println!("{}", x);
+    println!("{}", add_one(&*x)); // error: cannot borrow immutable dereference
+                                  // of `&`-pointer as mutable
 }
 ```
 
-Notice the signature of `increment()` requests a mutable reference.
+Notice we changed the signature of `add_one()` to request a mutable reference.
 
 ## Best practices
 

branches/beta/src/doc/trpl/unsafe.md

@@ -93,6 +93,10 @@ offered by the Rust language and libraries. For example, they
 - are plain-old-data, that is, they don't move ownership, again unlike
   `Box`, hence the Rust compiler cannot protect against bugs like
   use-after-free;
+- are considered sendable (if their contents is considered sendable),
+  so the compiler offers no assistance with ensuring their use is
+  thread-safe; for example, one can concurrently access a `*mut i32`
+  from two threads without synchronization.
 - lack any form of lifetimes, unlike `&`, and so the compiler cannot
   reason about dangling pointers; and
 - have no guarantees about aliasing or mutability other than mutation

branches/beta/src/libcore/num/mod.rs

@@ -345,16 +345,6 @@ pub trait Int
 
     /// Saturating integer addition. Computes `self + other`, saturating at
     /// the numeric bounds instead of overflowing.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u16.saturating_add(65534), 65535);
-    /// assert_eq!((-5i16).saturating_add(-32767), -32768);
-    /// assert_eq!(100u32.saturating_add(4294967294), 4294967295);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     fn saturating_add(self, other: Self) -> Self {
@@ -367,16 +357,6 @@ pub trait Int
 
     /// Saturating integer subtraction. Computes `self - other`, saturating at
     /// the numeric bounds instead of overflowing.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::num::Int;
-    ///
-    /// assert_eq!(5u16.saturating_sub(65534), 0);
-    /// assert_eq!(5i16.saturating_sub(-32767), 32767);
-    /// assert_eq!(100u32.saturating_sub(4294967294), 0);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     fn saturating_sub(self, other: Self) -> Self {

branches/beta/src/librustc/middle/astencode.rs

@@ -235,27 +235,12 @@ impl<'a, 'b, 'tcx> DecodeContext<'a, 'b, 'tcx> {
     pub fn tr_span(&self, span: Span) -> Span {
         let imported_filemaps = &self.cdata.codemap_import_info[..];
 
-        let span = if span.lo > span.hi {
-            // Currently macro expansion sometimes produces invalid Span values
-            // where lo > hi. In order not to crash the compiler when trying to
-            // translate these values, let's transform them into something we
-            // can handle (and which will produce useful debug locations at
-            // least some of the time).
-            // This workaround is only necessary as long as macro expansion is
-            // not fixed. FIXME(#23480)
-            codemap::mk_sp(span.lo, span.lo)
-        } else {
-            span
-        };
-
         let filemap_index = {
             // Optimize for the case that most spans within a translated item
             // originate from the same filemap.
             let last_filemap_index = self.last_filemap_index.get();
 
             if span.lo >= imported_filemaps[last_filemap_index].original_start_pos &&
-               span.lo <= imported_filemaps[last_filemap_index].original_end_pos &&
-               span.hi >= imported_filemaps[last_filemap_index].original_start_pos &&
                span.hi <= imported_filemaps[last_filemap_index].original_end_pos {
                 last_filemap_index
             } else {

branches/beta/src/librustc_back/tempdir.rs

@@ -61,12 +61,12 @@ impl TempDir {
             let path = tmpdir.join(&leaf);
             match fs::create_dir(&path) {
                 Ok(_) => return Ok(TempDir { path: Some(path) }),
-                Err(ref e) if e.kind() == ErrorKind::AlreadyExists => {}
+                Err(ref e) if e.kind() == ErrorKind::PathAlreadyExists => {}
                 Err(e) => return Err(e)
             }
         }
 
-        Err(Error::new(ErrorKind::AlreadyExists,
+        Err(Error::new(ErrorKind::PathAlreadyExists,
                        "too many temporary directories already exist",
                        None))
     }

branches/beta/src/librustdoc/html/render.rs

@@ -692,23 +692,16 @@ fn shortty(item: &clean::Item) -> ItemType {
 
 /// Takes a path to a source file and cleans the path to it. This canonicalizes
 /// things like ".." to components which preserve the "top down" hierarchy of a
-/// static HTML tree. Each component in the cleaned path will be passed as an
-/// argument to `f`. The very last component of the path (ie the file name) will
-/// be passed to `f` if `keep_filename` is true, and ignored otherwise.
+/// static HTML tree.
 // FIXME (#9639): The closure should deal with &[u8] instead of &str
 // FIXME (#9639): This is too conservative, rejecting non-UTF-8 paths
-fn clean_srcpath<F>(src_root: &Path, p: &Path, keep_filename: bool, mut f: F) where
+fn clean_srcpath<F>(src_root: &Path, p: &Path, mut f: F) where
     F: FnMut(&str),
 {
     // make it relative, if possible
     let p = p.relative_from(src_root).unwrap_or(p);
 
-    let mut iter = p.iter().map(|x| x.to_str().unwrap()).peekable();
-    while let Some(c) = iter.next() {
-        if !keep_filename && iter.peek().is_none() {
-            break;
-        }
-
+    for c in p.iter().map(|x| x.to_str().unwrap()) {
         if ".." == c {
             f("up");
         } else {
@@ -810,7 +803,7 @@ impl<'a> SourceCollector<'a> {
         // Create the intermediate directories
         let mut cur = self.dst.clone();
         let mut root_path = String::from_str("../../");
-        clean_srcpath(&self.cx.src_root, &p, false, |component| {
+        clean_srcpath(&self.cx.src_root, &p, |component| {
             cur.push(component);
             mkdir(&cur).unwrap();
             root_path.push_str("../");
@@ -1375,7 +1368,7 @@ impl<'a> Item<'a> {
         if ast_util::is_local(self.item.def_id) {
             let mut path = Vec::new();
             clean_srcpath(&cx.src_root, Path::new(&self.item.source.filename),
-                          true, |component| {
+                          |component| {
                 path.push(component.to_string());
             });
             let href = if self.item.source.loline == self.item.source.hiline {

branches/beta/src/librustdoc/lib.rs

@@ -35,6 +35,7 @@
 #![feature(test)]
 #![feature(unicode)]
 #![feature(str_words)]
+#![feature(io)]
 #![feature(file_path)]
 #![feature(path_ext)]
 #![feature(path_relative_from)]

branches/beta/src/libserialize/lib.rs

@@ -31,6 +31,7 @@ Core encoding and decoding interfaces.
 #![feature(collections)]
 #![feature(core)]
 #![feature(int_uint)]
+#![feature(io)]
 #![feature(old_path)]
 #![feature(rustc_private)]
 #![feature(staged_api)]

branches/beta/src/libstd/fs/mod.rs

@@ -73,11 +73,6 @@ pub struct Metadata(fs_imp::FileAttr);
 /// will yield instances of `io::Result<DirEntry>`. Through a `DirEntry`
 /// information like the entry's path and possibly other metadata can be
 /// learned.
-///
-/// # Failure
-///
-/// This `io::Result` will be an `Err` if there's some sort of intermittent
-/// IO error during iteration.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct ReadDir(fs_imp::ReadDir);
 
@@ -498,7 +493,7 @@ pub fn copy<P: AsPath, Q: AsPath>(from: P, to: Q) -> io::Result<u64> {
     let from = from.as_path();
     let to = to.as_path();
     if !from.is_file() {
-        return Err(Error::new(ErrorKind::InvalidInput,
+        return Err(Error::new(ErrorKind::MismatchedFileTypeForOperation,
                               "the source path is not an existing file",
                               None))
     }
@@ -1139,7 +1134,7 @@ mod tests {
         let dir = &tmpdir.join("mkdir_error_twice");
         check!(fs::create_dir(dir));
         let e = fs::create_dir(dir).err().unwrap();
-        assert_eq!(e.kind(), ErrorKind::AlreadyExists);
+        assert_eq!(e.kind(), ErrorKind::PathAlreadyExists);
     }
 
     #[test]

branches/beta/src/libstd/fs/tempdir.rs

@@ -68,12 +68,12 @@ impl TempDir {
             let path = tmpdir.join(&leaf);
             match fs::create_dir(&path) {
                 Ok(_) => return Ok(TempDir { path: Some(path) }),
-                Err(ref e) if e.kind() == ErrorKind::AlreadyExists => {}
+                Err(ref e) if e.kind() == ErrorKind::PathAlreadyExists => {}
                 Err(e) => return Err(e)
             }
         }
 
-        Err(Error::new(ErrorKind::AlreadyExists,
+        Err(Error::new(ErrorKind::PathAlreadyExists,
                        "too many temporary directories already exist",
                        None))
     }