---

yaml
---
r: 275061
b: refs/heads/stable
c: aeda844
h: refs/heads/master
i:
  275059: 69ee1a5

Author: Dave Huseby

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 206e86b947b3fb6940615e866fbba79f26064118
+refs/heads/stable: aeda8445a7295b7ca9e836db8c0328829cd6ee21
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/RELEASES.md

@@ -94,11 +94,11 @@ Misc
   the `-Z unstable-options` flag.
 * [When running tests with `--test`, rustdoc will pass `--cfg`
   arguments to the compiler][1.7dt].
-* [The compiler is built with RPATH information by default][1.7rpa].
+* [The compiler is built with RPATH information by default][1.7rp].
   This means that it will be possible to run `rustc` when installed in
   unusual configurations without configuring the dynamic linker search
   path explicitly.
-* [`rustc` passes `--enable-new-dtags` to GNU ld][1.7dta]. This makes
+* [`rustc` passes `--enable-new-dtags` to GNU ld][1.7dt]. This makes
   any RPATH entries (emitted with `-C rpath`) *not* take precedence
   over `LD_LIBRARY_PATH`.
 
@@ -132,15 +132,15 @@ Compatibility Notes
 [1.7cp]: https://github.com/rust-lang/cargo/pull/2224
 [1.7d]: https://github.com/rust-lang/rust/pull/30724
 [1.7dt]: https://github.com/rust-lang/rust/pull/30372
-[1.7dta]: https://github.com/rust-lang/rust/pull/30394
+[1.7dt]: https://github.com/rust-lang/rust/pull/30394
 [1.7f]: https://github.com/rust-lang/rust/pull/30672
 [1.7h]: https://github.com/rust-lang/rust/pull/30818
 [1.7j]: https://github.com/rust-lang/rust/pull/30711
 [1.7ll]: https://github.com/rust-lang/rust/pull/30663
 [1.7m]: https://github.com/rust-lang/rust/pull/30381
 [1.7p]: https://github.com/rust-lang/rust/pull/30681
 [1.7rp]: https://github.com/rust-lang/rust/pull/29498
-[1.7rpa]: https://github.com/rust-lang/rust/pull/30353
+[1.7rp]: https://github.com/rust-lang/rust/pull/30353
 [1.7rr]: https://github.com/rust-lang/cargo/pull/2279
 [1.7sf]: https://github.com/rust-lang/rust/pull/30389
 [1.7utf8]: https://github.com/rust-lang/rust/pull/30740

branches/stable/src/doc/book/ownership.md

@@ -124,65 +124,21 @@ special annotation here, it’s the default thing that Rust does.
 ## The details
 
 The reason that we cannot use a binding after we’ve moved it is subtle, but
-important. 
-
-When we write code like this:
-
-```rust
-let x = 10;
-```
-
-Rust allocates memory for an integer [i32] on the [stack][sh], copies the bit
-pattern representing the value of 10 to the allocated memory and binds the
-variable name x to this memory region for future reference.
-
-Now consider the following code fragment:
+important. When we write code like this:
 
 ```rust
 let v = vec![1, 2, 3];
 
-let mut v2 = v;
-```
-
-The first line allocates memory for the vector object `v` on the stack like
-it does for `x` above. But in addition to that it also allocates some memory
-on the [heap][sh] for the actual data (`[1, 2, 3]`). Rust copies the address
-of this heap allocation to an internal pointer, which is part of the vector
-object placed on the stack (let's call it the data pointer). 
-
-It is worth pointing out (even at the risk of stating the obvious) that the
-vector object and its data live in separate memory regions instead of being a
-single contiguous memory allocation (due to reasons we will not go into at
-this point of time). These two parts of the vector (the one on the stack and
-one on the heap) must agree with each other at all times with regards to
-things like the length, capacity etc.
-
-When we move `v` to `v2`, rust actually does a bitwise copy of the vector
-object `v` into the stack allocation represented by `v2`. This shallow copy
-does not create a copy of the heap allocation containing the actual data.
-Which means that there would be two pointers to the contents of the vector
-both pointing to the same memory allocation on the heap. It would violate
-Rust’s safety guarantees by introducing a data race if one could access both
-`v` and `v2` at the same time. 
-
-For example if we truncated the vector to just two elements through `v2`:
-
-```rust
-# let v = vec![1, 2, 3];
-# let mut v2 = v;
-v2.truncate(2);
+let v2 = v;
 ```
 
-and `v1` were still accessible we'd end up with an invalid vector since `v1`
-would not know that the heap data has been truncated. Now, the part of the
-vector `v1` on the stack does not agree with the corresponding part on the
-heap. `v1` still thinks there are three elements in the vector and will
-happily let us access the non existent element `v1[2]` but as you might
-already know this is a recipe for disaster. Especially because it might lead
-to a segmentation fault or worse allow an unauthorized user to read from
-memory to which they don't have access.
-
-This is why Rust forbids using `v` after we’ve done the move.
+The first line allocates memory for the vector object, `v`, and for the data it
+contains. The vector object is stored on the [stack][sh] and contains a pointer
+to the content (`[1, 2, 3]`) stored on the [heap][sh]. When we move `v` to `v2`,
+it creates a copy of that pointer, for `v2`. Which means that there would be two
+pointers to the content of the vector on the heap. It would violate Rust’s
+safety guarantees by introducing a data race. Therefore, Rust forbids using `v`
+after we’ve done the move.
 
 [sh]: the-stack-and-the-heap.html
 

branches/stable/src/libcollections/btree/map.rs

@@ -375,10 +375,9 @@ impl<K: Ord, V> BTreeMap<K, V> {
     ///
     /// If the map did not have this key present, `None` is returned.
     ///
-    /// If the map did have this key present, the value is updated, and the old
-    /// value is returned. The key is not updated, though; this matters for
-    /// types that can be `==` without being identical. See the [module-level
-    /// documentation] for more.
+    /// If the map did have this key present, the key is not updated, the
+    /// value is updated and the old value is returned.
+    /// See the [module-level documentation] for more.
     ///
     /// [module-level documentation]: index.html#insert-and-complex-keys
     ///

branches/stable/src/libcore/fmt/mod.rs

@@ -121,10 +121,6 @@ pub trait Write {
                 self.0.write_str(s)
             }
 
-            fn write_char(&mut self, c: char) -> Result {
-                self.0.write_char(c)
-            }
-
             fn write_fmt(&mut self, args: Arguments) -> Result {
                 self.0.write_fmt(args)
             }

branches/stable/src/libcore/mem.rs

@@ -571,25 +571,9 @@ pub const POST_DROP_USIZE: usize = POST_DROP_U64 as usize;
 /// ```
 /// use std::mem;
 ///
-/// #[repr(packed)]
-/// struct Foo {
-///     bar: u8,
-/// }
-///
-/// let foo_slice = [10u8];
-///
-/// unsafe {
-///     // Copy the data from 'foo_slice' and treat it as a 'Foo'
-///     let mut foo_struct: Foo = mem::transmute_copy(&foo_slice);
-///     assert_eq!(foo_struct.bar, 10);
-///
-///     // Modify the copied data
-///     foo_struct.bar = 20;
-///     assert_eq!(foo_struct.bar, 20);
-/// }
+/// let one = unsafe { mem::transmute_copy(&1) };
 ///
-/// // The contents of 'foo_slice' should not have changed
-/// assert_eq!(foo_slice, [10]);
+/// assert_eq!(1, one);
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]

branches/stable/src/liblibc

@@ -1 +1 @@
-Subproject commit 403bdc88394919f297bdb365032044cc0481c319
+Subproject commit a64ee24718c0289b82a77d692cf56f8a1226de51