---

yaml
---
r: 191087
b: refs/heads/auto
c: 13fd0a1
h: refs/heads/master
i:
  191085: f903372
  191083: 5a2f917
  191079: 2ea89ba
  191071: 681e17e
v: v3

Author: Tero Hänninen

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 90e7f472f7b1a71998e0133f00b615524cc36a33
+refs/heads/auto: 13fd0a1c68b699a5d85e868cce4af7992fbd0d6c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/Makefile.in

@@ -97,12 +97,7 @@
 #     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
-#
-# 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
+#     make check-stage1-std RUST_TEST_TASKS=1
 #
 # If you really feel like getting your hands dirty, then:
 #

branches/auto/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/auto/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/auto/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/auto/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/auto/src/liballoc/arc.rs

@@ -210,21 +210,6 @@ impl<T> Arc<T> {
         // contents.
         unsafe { &**self._ptr }
     }
-
-    // Non-inlined part of `drop`.
-    #[inline(never)]
-    unsafe fn drop_slow(&mut self) {
-        let ptr = *self._ptr;
-
-        // Destroy the data at this time, even though we may not free the box allocation itself
-        // (there may still be weak pointers lying around).
-        drop(ptr::read(&self.inner().data));
-
-        if self.inner().weak.fetch_sub(1, Release) == 1 {
-            atomic::fence(Acquire);
-            deallocate(ptr as *mut u8, size_of::<ArcInner<T>>(), min_align_of::<ArcInner<T>>())
-        }
-    }
 }
 
 /// Get the number of weak references to this value.
@@ -340,7 +325,6 @@ impl<T: Sync + Send> Drop for Arc<T> {
     ///
     /// } // implicit drop
     /// ```
-    #[inline]
     fn drop(&mut self) {
         // This structure has #[unsafe_no_drop_flag], so this drop glue may run more than once (but
         // it is guaranteed to be zeroed after the first if it's run more than once)
@@ -369,8 +353,14 @@ impl<T: Sync + Send> Drop for Arc<T> {
         // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
         atomic::fence(Acquire);
 
-        unsafe {
-            self.drop_slow()
+        // Destroy the data at this time, even though we may not free the box allocation itself
+        // (there may still be weak pointers lying around).
+        unsafe { drop(ptr::read(&self.inner().data)); }
+
+        if self.inner().weak.fetch_sub(1, Release) == 1 {
+            atomic::fence(Acquire);
+            unsafe { deallocate(ptr as *mut u8, size_of::<ArcInner<T>>(),
+                                min_align_of::<ArcInner<T>>()) }
         }
     }
 }

branches/auto/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/auto/src/libcore/str/pattern.rs

@@ -25,7 +25,7 @@ use super::CharEq;
 ///
 /// The trait itself acts as a builder for an associated
 /// `Searcher` type, which does the actual work of finding
-/// occurrences of the pattern in a string.
+/// occurences of the pattern in a string.
 pub trait Pattern<'a>: Sized {
     /// Associated searcher for this pattern
     type Searcher: Searcher<'a>;
@@ -72,7 +72,7 @@ pub enum SearchStep {
     /// Expresses that `haystack[a..b]` has been rejected as a possible match
     /// of the pattern.
     ///
-    /// Note that there might be more than one `Reject` between two `Match`es,
+    /// Note that there might be more than one `Reject` betwen two `Match`es,
     /// there is no requirement for them to be combined into one.
     Reject(usize, usize),
     /// Expresses that every byte of the haystack has been visted, ending

branches/auto/src/librbml/lib.rs

@@ -1061,7 +1061,7 @@ pub mod writer {
         }
 
         /// Returns the current position while marking it stable, i.e.
-        /// generated bytes so far wouldn't be affected by relaxation.
+        /// generated bytes so far woundn't be affected by relaxation.
         pub fn mark_stable_position(&mut self) -> u64 {
             let pos = self.writer.seek(SeekFrom::Current(0)).unwrap();
             if self.relax_limit < pos {

branches/auto/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/auto/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/auto/src/librustc_trans/trans/type_of.rs

@@ -264,7 +264,7 @@ pub fn arg_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
 }
 
 /// Get the LLVM type corresponding to a Rust type, i.e. `middle::ty::Ty`.
-/// This is the right LLVM type for an alloca containing a value of that type,
+/// This is the right LLVM type for an alloca containg a value of that type,
 /// and the pointee of an Lvalue Datum (which is always a LLVM pointer).
 /// For unsized types, the returned type is a fat pointer, thus the resulting
 /// LLVM type for a `Trait` Lvalue is `{ i8*, void(i8*)** }*`, which is a double

branches/auto/src/librustc_typeck/check/regionck.rs

@@ -225,7 +225,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
     /// }
     /// ```
     ///
-    /// Here, the region of `b` will be `<R0>`.  `<R0>` is constrained to be some subregion of the
+    /// Here, the region of `b` will be `<R0>`.  `<R0>` is constrainted to be some subregion of the
     /// block B and some superregion of the call.  If we forced it now, we'd choose the smaller
     /// region (the call).  But that would make the *b illegal.  Since we don't resolve, the type
     /// of b will be `&<R0>.int` and then `*b` will require that `<R0>` be bigger than the let and

branches/auto/src/librustc_typeck/check/upvar.rs

@@ -294,7 +294,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> {
 
     /// Indicates that `cmt` is being directly mutated (e.g., assigned
     /// to). If cmt contains any by-ref upvars, this implies that
-    /// those upvars must be borrowed using an `&mut` borrow.
+    /// those upvars must be borrowed using an `&mut` borow.
     fn adjust_upvar_borrow_kind_for_mut(&mut self, cmt: mc::cmt<'tcx>) {
         debug!("adjust_upvar_borrow_kind_for_mut(cmt={})",
                cmt.repr(self.tcx()));

branches/auto/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/auto/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/auto/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/auto/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/auto/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))
     }