---

yaml
---
r: 194952
b: refs/heads/auto
c: bf9c27d
h: refs/heads/master
v: v3

Author: apasel422

[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: f55d03c8d8f5cf76628da771c1f5c4b9a9589c00
+refs/heads/auto: bf9c27d8857fc532b56fb211ec1df629f8dc68dd
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -404,7 +404,7 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=pc-windows-gnu
         ;;
 
-# Thad's Cygwin identifiers below
+# Thad's Cygwin identifers below
 
 #   Vista 32 bit
     CYGWIN_NT-6.0)

branches/auto/mk/platform.mk

@@ -179,7 +179,7 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On Bitrig, we need the relocation model to be PIC for everything
+  # On Bitrig, we need the relocation model to be PIC for everthing
   ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
     LLVM_MC_RELOCATION_MODEL="pic"
   else

branches/auto/mk/target.mk

@@ -132,7 +132,7 @@ endef
 # on $$(TSREQ$(1)_T_$(2)_H_$(3)), to ensure that no products will be
 # put into the target area until after the get-snapshot.py script has
 # had its chance to clean it out; otherwise the other products will be
-# inadvertently included in the clean out.
+# inadvertantly included in the clean out.
 SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD))/rustc$(X_$(CFG_BUILD))
 
 define TARGET_HOST_RULES

branches/auto/src/doc/trpl/arrays-vectors-and-slices.md

@@ -99,4 +99,5 @@ You can also take a slice of a vector, `String`, or `&str`, because they are
 backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover
 generics.
 
-We have now learned all of the most basic Rust concepts.
+We have now learned all of the most basic Rust concepts. Next, we learn how to
+get input from the keyboard.

branches/auto/src/doc/trpl/associated-types.md

@@ -170,7 +170,7 @@ let obj = Box::new(graph) as Box<Graph>;
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ```
 
-We can’t create a trait object like this, because we don’t know the associated
+We can’t create a trait object like this, becuase we don’t know the associated
 types. Instead, we can write this:
 
 ```rust

branches/auto/src/doc/trpl/documentation.md

@@ -529,7 +529,7 @@ This will create documentation for bar both inside the documentation for the
 crate `foo`, as well as the documentation for your crate. It will use the same
 documentation in both places.
 
-This behavior can be suppressed with `no_inline`:
+This behavior can be supressed with `no_inline`:
 
 ```ignore
 extern crate foo;

branches/auto/src/etc/rustup.sh

@@ -335,7 +335,7 @@ case $CFG_OSTYPE in
     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;
-# Thad's Cygwin identifiers below
+# Thad's Cygwin identifers below
 
 #   Vista 32 bit
     CYGWIN_NT-6.0)
@@ -437,7 +437,7 @@ CFG_TMP_DIR=$(mktemp -d 2>/dev/null \
            || create_tmp_dir)
 
 # If we're saving nightlies and we didn't specify which one, grab the latest
-# version from the perspective of the server. Buildbot has typically finished
+# verison from the perspective of the server. Buildbot has typically finished
 # building and uploading by ~8UTC, but we want to include a little buffer.
 #
 # FIXME It would be better to use the known most recent nightly that has been

branches/auto/src/libcore/marker.rs

@@ -476,7 +476,7 @@ pub struct InvariantType<T>;
 /// particular, thanks to the `Reflect` bound, callers know that a
 /// function declared like `fn bar<T>(...)` will always act in
 /// precisely the same way no matter what type `T` is supplied,
-/// because there are no bounds declared on `T`. (The ability for a
+/// beacuse there are no bounds declared on `T`. (The ability for a
 /// caller to reason about what a function may do based solely on what
 /// generic bounds are declared is often called the ["parametricity
 /// property"][1].)

branches/auto/src/librbml/lib.rs

@@ -83,7 +83,7 @@
 //! - `Sub32` (`0d`): 4-byte unsigned integer for supplementary information.
 //!   Those two tags normally occur as the first subdocument of certain tags,
 //!   namely `Enum`, `Vec` and `Map`, to provide a variant or size information.
-//!   They can be used interchangeably.
+//!   They can be used interchangably.
 //!
 //! Predefined tags with an explicit length:
 //!

branches/auto/src/librustc_back/target/mod.rs

@@ -157,7 +157,7 @@ pub struct TargetOptions {
     /// particular running dsymutil and some other stuff like `-dead_strip`. Defaults to false.
     pub is_like_osx: bool,
     /// Whether the target toolchain is like Windows'. Only useful for compiling against Windows,
-    /// only really used for figuring out how to find libraries, since Windows uses its own
+    /// only realy used for figuring out how to find libraries, since Windows uses its own
     /// library naming convention. Defaults to false.
     pub is_like_windows: bool,
     /// Whether the target toolchain is like Android's. Only useful for compiling against Android.

branches/auto/src/librustdoc/html/static/main.css

@@ -493,10 +493,6 @@ h1 .stability {
 .stability.Locked { border-color: #0084B6; color: #00668c; }
 .stability.Unmarked { border-color: #BBBBBB; }
 
-td.summary-column {
-    width: 100%;
-}
-
 .summary {
     padding-right: 0px;
 }

branches/auto/src/librustdoc/stability_summary.rs

@@ -86,7 +86,7 @@ impl Ord for ModuleSummary {
     }
 }
 
-// is the item considered publicly visible?
+// is the item considered publically visible?
 fn visible(item: &Item) -> bool {
     match item.inner {
         ImplItem(_) => true,

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

@@ -1511,7 +1511,7 @@ mod tests {
         assert_eq!(v, b"foobar\0\0\0\0".to_vec());
 
         // Truncate to a smaller length, don't seek, and then write something.
-        // Ensure that the intermediate zeroes are all filled in (we have `seek`ed
+        // Ensure that the intermediate zeroes are all filled in (we're seeked
         // past the end of the file).
         check!(file.set_len(2));
         assert_eq!(check!(file.metadata()).len(), 2);

branches/auto/src/libstd/io/buffered.rs

@@ -18,9 +18,8 @@ use io::prelude::*;
 use cmp;
 use error::{self, FromError};
 use fmt;
-use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind};
+use io::{self, Cursor, DEFAULT_BUF_SIZE, Error, ErrorKind};
 use ptr;
-use iter;
 
 /// Wraps a `Read` and buffers input from it
 ///
@@ -31,9 +30,7 @@ use iter;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BufReader<R> {
     inner: R,
-    buf: Vec<u8>,
-    pos: usize,
-    cap: usize,
+    buf: Cursor<Vec<u8>>,
 }
 
 impl<R: Read> BufReader<R> {
@@ -46,13 +43,9 @@ impl<R: Read> BufReader<R> {
     /// Creates a new `BufReader` with the specified buffer capacity
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
-        let mut buf = Vec::with_capacity(cap);
-        buf.extend(iter::repeat(0).take(cap));
         BufReader {
             inner: inner,
-            buf: buf,
-            pos: 0,
-            cap: 0,
+            buf: Cursor::new(Vec::with_capacity(cap)),
         }
     }
 
@@ -81,15 +74,12 @@ impl<R: Read> Read for BufReader<R> {
         // If we don't have any buffered data and we're doing a massive read
         // (larger than our internal buffer), bypass our internal buffer
         // entirely.
-        if self.pos == self.cap && buf.len() >= self.buf.len() {
+        if self.buf.get_ref().len() == self.buf.position() as usize &&
+            buf.len() >= self.buf.get_ref().capacity() {
             return self.inner.read(buf);
         }
-        let nread = {
-            let mut rem = try!(self.fill_buf());
-            try!(rem.read(buf))
-        };
-        self.consume(nread);
-        Ok(nread)
+        try!(self.fill_buf());
+        self.buf.read(buf)
     }
 }
 
@@ -98,25 +88,26 @@ impl<R: Read> BufRead for BufReader<R> {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         // If we've reached the end of our internal buffer then we need to fetch
         // some more data from the underlying reader.
-        if self.pos == self.cap {
-            self.cap = try!(self.inner.read(&mut self.buf));
-            self.pos = 0;
+        if self.buf.position() as usize == self.buf.get_ref().len() {
+            self.buf.set_position(0);
+            let v = self.buf.get_mut();
+            v.truncate(0);
+            let inner = &mut self.inner;
+            try!(super::with_end_to_cap(v, |b| inner.read(b)));
         }
-        Ok(&self.buf[self.pos..self.cap])
+        self.buf.fill_buf()
     }
 
     fn consume(&mut self, amt: usize) {
-        self.pos = cmp::min(self.pos + amt, self.cap);
+        self.buf.consume(amt)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("BufReader")
-            .field("reader", &self.inner)
-            .field("buffer", &format_args!("{}/{}", self.cap - self.pos, self.buf.len()))
-            .finish()
+        write!(fmt, "BufReader {{ reader: {:?}, buffer: {}/{} }}",
+               self.inner, self.buf.position(), self.buf.get_ref().len())
     }
 }
 
@@ -231,10 +222,8 @@ impl<W: Write> Write for BufWriter<W> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("BufWriter")
-            .field("writer", &self.inner.as_ref().unwrap())
-            .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
-            .finish()
+        write!(fmt, "BufWriter {{ writer: {:?}, buffer: {}/{} }}",
+               self.inner.as_ref().unwrap(), self.buf.len(), self.buf.capacity())
     }
 }
 
@@ -348,11 +337,9 @@ impl<W: Write> Write for LineWriter<W> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("LineWriter")
-            .field("writer", &self.inner.inner)
-            .field("buffer",
-                   &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
-            .finish()
+        write!(fmt, "LineWriter {{ writer: {:?}, buffer: {}/{} }}",
+               self.inner.inner, self.inner.buf.len(),
+               self.inner.buf.capacity())
     }
 }
 
@@ -428,10 +415,10 @@ impl<S: Read + Write> BufStream<S> {
     /// Any leftover data in the read buffer is lost.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>> {
-        let BufReader { inner: InternalBufWriter(w), buf, pos, cap } = self.inner;
+        let BufReader { inner: InternalBufWriter(w), buf } = self.inner;
         w.into_inner().map_err(|IntoInnerError(w, e)| {
             IntoInnerError(BufStream {
-                inner: BufReader { inner: InternalBufWriter(w), buf: buf, pos: pos, cap: cap },
+                inner: BufReader { inner: InternalBufWriter(w), buf: buf },
             }, e)
         })
     }
@@ -465,12 +452,10 @@ impl<S: Write> fmt::Debug for BufStream<S> where S: fmt::Debug {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let reader = &self.inner;
         let writer = &self.inner.inner.0;
-        fmt.debug_struct("BufStream")
-            .field("stream", &writer.inner)
-            .field("write_buffer", &format_args!("{}/{}", writer.buf.len(), writer.buf.capacity()))
-            .field("read_buffer",
-                   &format_args!("{}/{}", reader.cap - reader.pos, reader.buf.len()))
-            .finish()
+        write!(fmt, "BufStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}",
+               writer.inner,
+               writer.buf.len(), writer.buf.capacity(),
+               reader.buf.position(), reader.buf.get_ref().len())
     }
 }
 

branches/auto/src/libstd/io/mod.rs

@@ -48,6 +48,30 @@ mod stdio;
 
 const DEFAULT_BUF_SIZE: usize = 64 * 1024;
 
+// Acquires a slice of the vector `v` from its length to its capacity
+// (after initializing the data), reads into it, and then updates the length.
+//
+// This function is leveraged to efficiently read some bytes into a destination
+// vector without extra copying and taking advantage of the space that's already
+// in `v`.
+fn with_end_to_cap<F>(v: &mut Vec<u8>, f: F) -> Result<usize>
+    where F: FnOnce(&mut [u8]) -> Result<usize>
+{
+    let len = v.len();
+    let new_area = v.capacity() - len;
+    v.extend(iter::repeat(0).take(new_area));
+    match f(&mut v[len..]) {
+        Ok(n) => {
+            v.truncate(len + n);
+            Ok(n)
+        }
+        Err(e) => {
+            v.truncate(len);
+            Err(e)
+        }
+    }
+}
+
 // A few methods below (read_to_string, read_line) will append data into a
 // `String` buffer, but we need to be pretty careful when doing this. The
 // implementation will just call `.as_mut_vec()` and then delegate to a
@@ -92,45 +116,19 @@ fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
     }
 }
 
-// This uses an adaptive system to extend the vector when it fills. We want to
-// avoid paying to allocate and zero a huge chunk of memory if the reader only
-// has 4 bytes while still making large reads if the reader does have a ton
-// of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every
-// time is 4,500 times (!) slower than this if the reader has a very small
-// amount of data to return.
 fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
-    let start_len = buf.len();
-    let mut len = start_len;
-    let mut cap_bump = 16;
-    let ret;
+    let mut read = 0;
     loop {
-        if len == buf.len() {
-            if buf.capacity() == buf.len() {
-                if cap_bump < DEFAULT_BUF_SIZE {
-                    cap_bump *= 2;
-                }
-                buf.reserve(cap_bump);
-            }
-            let new_area = buf.capacity() - buf.len();
-            buf.extend(iter::repeat(0).take(new_area));
+        if buf.capacity() == buf.len() {
+            buf.reserve(DEFAULT_BUF_SIZE);
         }
-
-        match r.read(&mut buf[len..]) {
-            Ok(0) => {
-                ret = Ok(len - start_len);
-                break;
-            }
-            Ok(n) => len += n,
+        match with_end_to_cap(buf, |b| r.read(b)) {
+            Ok(0) => return Ok(read),
+            Ok(n) => read += n,
             Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
-            Err(e) => {
-                ret = Err(e);
-                break;
-            }
+            Err(e) => return Err(e),
         }
     }
-
-    buf.truncate(len);
-    ret
 }
 
 /// A trait for objects which are byte-oriented sources.

branches/auto/src/libstd/old_io/fs.rs

@@ -1532,7 +1532,7 @@ mod test {
                    b"foobar\0\0\0\0".to_vec());
 
         // Truncate to a smaller length, don't seek, and then write something.
-        // Ensure that the intermediate zeroes are all filled in (we have `seek`ed
+        // Ensure that the intermediate zeroes are all filled in (we're seeked
         // past the end of the file).
         check!(file.truncate(2));
         assert_eq!(check!(file.stat()).size, 2);

branches/auto/src/libtest/lib.rs

@@ -340,7 +340,7 @@ The FILTER regex is tested against the name of all tests to run, and
 only those tests that match are run.
 
 By default, all tests are run in parallel. This can be altered with the
-RUST_TEST_THRADS environment variable when running tests (set it to 1).
+RUST_TEST_THREADS environment variable when running tests (set it to 1).
 
 All tests have their standard output and standard error captured by default.
 This can be overridden with the --nocapture flag or the RUST_TEST_NOCAPTURE=1

branches/auto/src/test/compile-fail/issue-9814.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Verify that single-variant enums can't be de-referenced
+// Verify that single-variant enums cant be de-referenced
 // Regression test for issue #9814
 
 enum Foo { Bar(isize) }