---

yaml
---
r: 217071
b: refs/heads/stable
c: cce30b2
h: refs/heads/master
i:
  217069: ad364d4
  217067: 206f9d1
  217063: 6bfe552
  217055: 8772481
v: v3

Author: tamird

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 0a1a53d6933b53b804269ce236760847c5dd00fa
+refs/heads/stable: cce30b2ae659ac70b500f0bd1a2c7f71eeab0a41
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/configure

@@ -106,8 +106,8 @@ probe() {
         T=$(command -v $P 2>&1)
         if [ $? -eq 0 ]
         then
-            VER0=$($P --version 2>/dev/null \
-                |  grep -o '[vV]\?[0-9][0-9.][a-z0-9.-]*' | head -1 )
+            VER0=$($P --version 2>/dev/null | head -1 \
+                |  sed -e 's/[^0-9]*\([vV]\?[0-9.]\+[^ ]*\).*/\1/' )
             if [ $? -eq 0 -a "x${VER0}" != "x" ]
             then
               VER="($VER0)"
@@ -711,20 +711,6 @@ else
     probe_need CFG_GIT     git
 fi
 
-# Use `md5sum` on GNU platforms, or `md5 -q` on BSD
-probe CFG_MD5              md5
-probe CFG_MD5SUM           md5sum
-if [ -n "$CFG_MD5" ]
-then
-    CFG_HASH_COMMAND="$CFG_MD5 -q | head -c 8"
-elif [ -n "$CFG_MD5SUM" ]
-then
-    CFG_HASH_COMMAND="$CFG_MD5SUM | head -c 8"
-else
-    err 'could not find one of: md5 md5sum'
-fi
-putvar CFG_HASH_COMMAND
-
 probe CFG_CLANG            clang++
 probe CFG_CCACHE           ccache
 probe CFG_GCC              gcc

branches/stable/mk/main.mk

@@ -20,9 +20,7 @@ CFG_RELEASE_NUM=1.1.0
 # versions (section 9)
 CFG_PRERELEASE_VERSION=.1
 
-# Append a version-dependent hash to each library, so we can install different
-# versions in the same place
-CFG_FILENAME_EXTRA=$(shell printf '%s' $(CFG_RELEASE) | $(CFG_HASH_COMMAND))
+CFG_FILENAME_EXTRA=4e7c5e5c
 
 ifeq ($(CFG_RELEASE_CHANNEL),stable)
 # This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly"

branches/stable/src/doc/reference.md

@@ -1346,8 +1346,6 @@ vtable when the trait is used as a [trait object](#trait-objects).
 Traits are implemented for specific types through separate
 [implementations](#implementations).
 
-Consider the following trait:
-
 ```
 # type Surface = i32;
 # type BoundingBox = i32;
@@ -1362,20 +1360,6 @@ This defines a trait with two methods. All values that have
 `draw` and `bounding_box` methods called, using `value.bounding_box()`
 [syntax](#method-call-expressions).
 
-Traits can include default implementations of methods, as in:
-
-```
-trait Foo {
-    fn bar(&self);
-
-    fn baz(&self) { println!("We called baz."); }
-}
-```
-
-Here the `baz` method has a default implementation, so types that implement
-`Foo` need only implement `bar`. It is also possible for implementing types
-to override a method that has a default implementation.
-
 Type parameters can be specified for a trait to make it generic. These appear
 after the trait name, using the same syntax used in [generic
 functions](#generic-functions).
@@ -1388,35 +1372,6 @@ trait Seq<T> {
 }
 ```
 
-It is also possible to define associated types for a trait. Consider the
-following example of a `Container` trait. Notice how the type is available
-for use in the method signatures:
-
-```
-trait Container {
-    type E;
-    fn empty() -> Self;
-    fn insert(&mut self, Self::E);
-}
-```
-
-In order for a type to implement this trait, it must not only provide
-implementations for every method, but it must specify the type `E`. Here's
-an implementation of `Container` for the standard library type `Vec`:
-
-```
-# trait Container {
-#     type E;
-#     fn empty() -> Self;
-#     fn insert(&mut self, Self::E);
-# }
-impl<T> Container for Vec<T> {
-    type E = T;
-    fn empty() -> Vec<T> { Vec::new() }
-    fn insert(&mut self, x: T) { self.push(x); }
-}
-```
-
 Generic functions may use traits as _bounds_ on their type parameters. This
 will have two effects: only types that have the trait may instantiate the
 parameter, and within the generic function, the methods of the trait can be
@@ -3515,21 +3470,13 @@ more of the closure traits:
 
 ### Trait objects
 
-In Rust, a type like `&SomeTrait` or `Box<SomeTrait>` is called a _trait object_.
-Each instance of a trait object includes:
-
- - a pointer to an instance of a type `T` that implements `SomeTrait`
- - a _virtual method table_, often just called a _vtable_, which contains, for
-   each method of `SomeTrait` that `T` implements, a pointer to `T`'s
-   implementation (i.e. a function pointer).
-
-The purpose of trait objects is to permit "late binding" of methods. A call to
-a method on a trait object is only resolved to a vtable entry at compile time.
-The actual implementation for each vtable entry can vary on an object-by-object
-basis.
-
-Note that for a trait object to be instantiated, the trait must be
-_object-safe_. Object safety rules are defined in [RFC 255][rfc255].
+Every trait item (see [traits](#traits)) defines a type with the same name as
+the trait. This type is called the _trait object_ of the trait. Trait objects
+permit "late binding" of methods, dispatched using _virtual method tables_
+("vtables"). Whereas most calls to trait methods are "early bound" (statically
+resolved) to specific implementations at compile time, a call to a method on an
+trait objects is only resolved to a vtable entry at compile time. The actual
+implementation for each vtable entry can vary on an object-by-object basis.
 
 Given a pointer-typed expression `E` of type `&T` or `Box<T>`, where `T`
 implements trait `R`, casting `E` to the corresponding pointer type `&R` or

branches/stable/src/doc/trpl/README.md

@@ -175,7 +175,7 @@ data, we call the `clone()` method. In this example, `y` is no longer a referenc
 to the vector stored in `x`, but a copy of its first element, `"Hello"`. Now
 that we don’t have a reference, our `push()` works just fine.
 
-[move]: ownership.html#move-semantics
+[move]: move-semantics.html
 
 If we truly want a reference, we need the other option: ensure that our reference
 goes out of scope before we try to do the mutation. That looks like this:

branches/stable/src/doc/trpl/dining-philosophers.md

@@ -450,7 +450,7 @@ which blocks execution until the thread has completed execution. This ensures
 that the threads complete their work before the program exits.
 
 If you run this program, you’ll see that the philosophers eat out of order!
-We have multi-threading!
+We have mult-threading!
 
 ```text
 Gilles Deleuze is eating.

branches/stable/src/doc/trpl/error-handling.md

@@ -181,8 +181,6 @@ match version {
 This function makes use of an enum, `ParseError`, to enumerate the various
 errors that can occur.
 
-The [`Debug`](../std/fmt/trait.Debug.html) trait is what lets us print the enum value using the `{:?}` format operation.
-
 # Non-recoverable errors with `panic!`
 
 In the case of an error that is unexpected and not recoverable, the `panic!`

branches/stable/src/doc/trpl/the-stack-and-the-heap.md

@@ -266,7 +266,7 @@ Rust programs use [jemalloc][jemalloc] for this purpose.
 Anyway, back to our example. Since this memory is on the heap, it can stay
 alive longer than the function which allocates the box. In this case, however,
 it doesn’t.[^moving] When the function is over, we need to free the stack frame
-for `main()`. `Box<T>`, though, has a trick up its sleeve: [Drop][drop]. The
+for `main()`. `Box<T>`, though, has a trick up its sleve: [Drop][drop]. The
 implementation of `Drop` for `Box` deallocates the memory that was allocated
 when it was created. Great! So when `x` goes away, it first frees the memory
 allocated on the heap:

branches/stable/src/libcollections/vec.rs

@@ -18,41 +18,39 @@
 //! You can explicitly create a `Vec<T>` with `new()`:
 //!
 //! ```
-//! let v: Vec<i32> = Vec::new();
+//! let xs: Vec<i32> = Vec::new();
 //! ```
 //!
 //! ...or by using the `vec!` macro:
 //!
 //! ```
-//! let v: Vec<i32> = vec![];
+//! let ys: Vec<i32> = vec![];
 //!
-//! let v = vec![1, 2, 3, 4, 5];
-//!
-//! let v = vec![0; 10]; // ten zeroes
+//! let zs = vec![1i32, 2, 3, 4, 5];
 //! ```
 //!
 //! You can `push` values onto the end of a vector (which will grow the vector as needed):
 //!
 //! ```
-//! let mut v = vec![1, 2];
+//! let mut xs = vec![1i32, 2];
 //!
-//! v.push(3);
+//! xs.push(3);
 //! ```
 //!
 //! Popping values works in much the same way:
 //!
 //! ```
-//! let mut v = vec![1, 2];
+//! let mut xs = vec![1i32, 2];
 //!
-//! let two = v.pop();
+//! let two = xs.pop();
 //! ```
 //!
 //! Vectors also support indexing (through the `Index` and `IndexMut` traits):
 //!
 //! ```
-//! let mut v = vec![1, 2, 3];
-//! let three = v[2];
-//! v[1] = v[1] + 5;
+//! let mut xs = vec![1i32, 2, 3];
+//! let three = xs[2];
+//! xs[1] = xs[1] + 5;
 //! ```
 
 #![stable(feature = "rust1", since = "1.0.0")]

branches/stable/src/libcore/macros.rs

@@ -167,7 +167,7 @@ macro_rules! try {
     })
 }
 
-/// Use the `format!` syntax to write data into a buffer of type `&mut Write`.
+/// Use the `format!` syntax to write data into a buffer of type `&mut Writer`.
 /// See `std::fmt` for more information.
 ///
 /// # Examples

branches/stable/src/librustc/diagnostics.rs

@@ -427,8 +427,8 @@ be taken.
 
 E0271: r##"
 This is because of a type mismatch between the associated type of some
-trait (e.g. `T::Bar`, where `T` implements `trait Quux { type Bar; }`)
-and another type `U` that is required to be equal to `T::Bar`, but is not.
+trait (e.g. T::Bar, where T implements trait Quux { type Bar; })
+and another type U that is required to be equal to T::Bar, but is not.
 Examples follow.
 
 Here is a basic example:

branches/stable/src/librustc_back/archive.rs

@@ -306,21 +306,6 @@ impl<'a> ArchiveBuilder<'a> {
             if filename.contains(".SYMDEF") { continue }
             if skip(filename) { continue }
 
-            // Archives on unix systems typically do not have slashes in
-            // filenames as the `ar` utility generally only uses the last
-            // component of a path for the filename list in the archive. On
-            // Windows, however, archives assembled with `lib.exe` will preserve
-            // the full path to the file that was placed in the archive,
-            // including path separators.
-            //
-            // The code below is munging paths so it'll go wrong pretty quickly
-            // if there's some unexpected slashes in the filename, so here we
-            // just chop off everything but the filename component. Note that
-            // this can cause duplicate filenames, but that's also handled below
-            // as well.
-            let filename = Path::new(filename).file_name().unwrap()
-                                              .to_str().unwrap();
-
             // An archive can contain files of the same name multiple times, so
             // we need to be sure to not have them overwrite one another when we
             // extract them. Consequently we need to find a truly unique file

branches/stable/src/librustc_resolve/diagnostics.rs

@@ -20,7 +20,6 @@ Imports (`use` statements) are not allowed after non-item statements, such as
 variable declarations and expression statements.
 
 Here is an example that demonstrates the error:
-
 ```
 fn f() {
     // Variable declaration before import
@@ -34,7 +33,6 @@ The solution is to declare the imports at the top of the block, function, or
 file.
 
 Here is the previous example again, with the correct order:
-
 ```
 fn f() {
     use std::io::Read;
@@ -54,7 +52,6 @@ The name chosen for an external crate conflicts with another external crate that
 has been imported into the current module.
 
 Wrong example:
-
 ```
 extern crate a;
 extern crate crate_a as a;
@@ -64,7 +61,6 @@ The solution is to choose a different name that doesn't conflict with any
 external crate imported into the current module.
 
 Correct example:
-
 ```
 extern crate a;
 extern crate crate_a as other_name;
@@ -75,7 +71,6 @@ E0260: r##"
 The name for an item declaration conflicts with an external crate's name.
 
 For instance,
-
 ```
 extern crate abc;
 

branches/stable/src/librustc_resolve/lib.rs

@@ -2528,18 +2528,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                 // If anything ends up here entirely resolved,
                                 // it's an error. If anything ends up here
                                 // partially resolved, that's OK, because it may
-                                // be a `T::CONST` that typeck will resolve.
+                                // be a `T::CONST` that typeck will resolve to
+                                // an inherent impl.
                                 if path_res.depth == 0 {
                                     self.resolve_error(
                                         path.span,
                                         &format!("`{}` is not an enum variant, struct or const",
                                                  token::get_ident(
                                                      path.segments.last().unwrap().identifier)));
                                 } else {
-                                    let const_name = path.segments.last().unwrap()
-                                                         .identifier.name;
-                                    let traits = self.get_traits_containing_item(const_name);
-                                    self.trait_map.insert(pattern.id, traits);
                                     self.record_def(pattern.id, path_res);
                                 }
                             }