---

yaml
---
r: 235435
b: refs/heads/stable
c: 68781e2
h: refs/heads/master
i:
  235433: 3b11a77
  235431: 6fae094
v: v3

Author: brson

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 9ac3f4277163ff8b537b998ac1549111d32f8289
+refs/heads/stable: 68781e25c5465021d25e2ff9d3818577e70c6545
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/CONTRIBUTING.md

@@ -133,8 +133,8 @@ Documentation improvements are very welcome. The source of `doc.rust-lang.org`
 is located in `src/doc` in the tree, and standard API documentation is generated
 from the source code itself.
 
-Documentation pull requests function in the same way as other pull requests,
-though you may see a slightly different form of `r+`:
+Documentation pull requests function in the same as other pull requests, though
+you may see a slightly different form of `r+`:
 
     @bors: r+ 38fe8d2 rollup
 

branches/stable/RELEASES.md

@@ -28,9 +28,6 @@ Breaking Changes
   in, and the same value reported by clang's
   `alignof`. [`mem::min_align_of`] is deprecated. This is not known to
   break real code.
-* [The `#[packed]` attribute is no longer silently accepted by the
-  compiler][packed]. This attribute did nothing and code that
-  mentioned it likely did not work as intended.
 
 Language
 --------
@@ -143,7 +140,7 @@ Misc
 [fat]: https://github.com/rust-lang/rust/pull/26411
 [dst]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
 [parcodegen]: https://github.com/rust-lang/rust/pull/26018
-[packed]: https://github.com/rust-lang/rust/pull/25541
+
 
 Version 1.1.0 (June 2015)
 =========================

branches/stable/src/doc/trpl/inline-assembly.md

@@ -103,7 +103,7 @@ fn main() {
 If you would like to use real operands in this position, however,
 you are required to put curly braces `{}` around the register that
 you want, and you are required to put the specific size of the
-operand. This is useful for very low level programming, where
+operand. This is useful for very low level programming, where 
 which register you use is important:
 
 ```rust
@@ -166,12 +166,3 @@ unsafe {
 println!("eax is currently {}", result);
 # }
 ```
-
-## More Information
-
-The current implementation of the `asm!` macro is a direct binding to [LLVM's
-inline assembler expressions][llvm-docs], so be sure to check out [their
-documentation as well][llvm-docs] for more information about clobbers,
-constraints, etc.
-
-[llvm-docs]: http://llvm.org/docs/LangRef.html#inline-assembler-expressions

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

@@ -42,8 +42,8 @@ With that in mind, let’s learn about ownership.
 # Ownership
 
 [Variable bindings][bindings] have a property in Rust: they ‘have ownership’
-of what they’re bound to. This means that when a binding goes out of scope, 
-Rust will free the bound resources. For example:
+of what they’re bound to. This means that when a binding goes out of scope, the
+resource that they’re bound to are freed. For example:
 
 ```rust
 fn foo() {

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

@@ -176,7 +176,7 @@ After `bar()` is over, its frame is deallocated, leaving just `foo()` and
 | 1       | a    | 5     |
 | 0       | x    | 42    |
 
-And then `foo()` ends, leaving just `main()`:
+And then `foo()` ends, leaving just `main()`
 
 | Address | Name | Value |
 |---------|------|-------|
@@ -537,7 +537,7 @@ Generally, you should prefer stack allocation, and so, Rust stack-allocates by
 default. The LIFO model of the stack is simpler, at a fundamental level. This
 has two big impacts: runtime efficiency and semantic impact.
 
-## Runtime Efficiency
+## Runtime Efficiency.
 
 Managing the memory for the stack is trivial: The machine just
 increments or decrements a single value, the so-called “stack pointer”.

branches/stable/src/libcollections/str.rs

@@ -550,14 +550,6 @@ impl str {
         core_str::StrExt::slice_unchecked(self, begin, end)
     }
 
-    /// Takes a bytewise mutable slice from a string.
-    ///
-    /// Same as `slice_unchecked`, but works with `&mut str` instead of `&str`.
-    #[unstable(feature = "str_slice_mut", reason = "recently added")]
-    pub unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str {
-        core_str::StrExt::slice_mut_unchecked(self, begin, end)
-    }
-
     /// Returns a slice of the string from the character range [`begin`..`end`).
     ///
     /// That is, start at the `begin`-th code point of the string and continue
@@ -784,7 +776,7 @@ impl str {
     ///
     /// # Examples
     /// ```
-    /// # #![feature(str_split_at)]
+    /// # #![feature(collections)]
     /// let s = "Löwe 老虎 Léopard";
     /// let first_space = s.find(' ').unwrap_or(s.len());
     /// let (a, b) = s.split_at(first_space);
@@ -793,18 +785,10 @@ impl str {
     /// assert_eq!(b, " 老虎 Léopard");
     /// ```
     #[inline]
-    #[unstable(feature = "str_split_at", reason = "recently added")]
     pub fn split_at(&self, mid: usize) -> (&str, &str) {
         core_str::StrExt::split_at(self, mid)
     }
 
-    /// Divide one mutable string slice into two at an index.
-    #[inline]
-    #[unstable(feature = "str_split_at", reason = "recently added")]
-    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str) {
-        core_str::StrExt::split_at_mut(self, mid)
-    }
-
     /// An iterator over the codepoints of `self`.
     ///
     /// # Examples

branches/stable/src/libcollections/string.rs

@@ -979,38 +979,6 @@ impl ops::Index<ops::RangeFull> for String {
     }
 }
 
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::Range<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeTo<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[cfg(not(stage0))]
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeFrom<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::IndexMut<ops::RangeFull> for String {
-    #[inline]
-    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
-        unsafe { mem::transmute(&mut *self.vec) }
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl ops::Deref for String {
     type Target = str;
@@ -1021,14 +989,6 @@ impl ops::Deref for String {
     }
 }
 
-#[stable(feature = "derefmut_for_string", since = "1.2.0")]
-impl ops::DerefMut for String {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut str {
-        unsafe { mem::transmute(&mut self.vec[..]) }
-    }
-}
-
 /// Wrapper type providing a `&String` reference via `Deref`.
 #[unstable(feature = "collections")]
 #[deprecated(since = "1.2.0",

branches/stable/src/libcollectionstest/lib.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(ascii)]
 #![feature(append)]
 #![feature(bitset)]
 #![feature(bitvec)]
@@ -44,7 +43,6 @@
 #![feature(str_char)]
 #![feature(str_escape)]
 #![feature(str_match_indices)]
-#![feature(str_split_at)]
 #![feature(str_utf16)]
 #![feature(box_str)]
 #![feature(subslice_offset)]

branches/stable/src/libcollectionstest/str.rs

@@ -701,18 +701,6 @@ fn test_split_at() {
     assert_eq!(b, "");
 }
 
-#[test]
-fn test_split_at_mut() {
-    use std::ascii::AsciiExt;
-    let mut s = "Hello World".to_string();
-    {
-        let (a, b) = s.split_at_mut(5);
-        a.make_ascii_uppercase();
-        b.make_ascii_lowercase();
-    }
-    assert_eq!(s, "HELLO world");
-}
-
 #[test]
 #[should_panic]
 fn test_split_at_boundscheck() {

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

@@ -1116,23 +1116,6 @@ mod traits {
         }
     }
 
-    /// Returns a mutable slice of the given string from the byte range
-    /// [`begin`..`end`).
-    #[stable(feature = "derefmut_for_string", since = "1.2.0")]
-    impl ops::IndexMut<ops::Range<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
-            // is_char_boundary checks that the index is in [0, .len()]
-            if index.start <= index.end &&
-               self.is_char_boundary(index.start) &&
-               self.is_char_boundary(index.end) {
-                unsafe { self.slice_mut_unchecked(index.start, index.end) }
-            } else {
-                super::slice_error_fail(self, index.start, index.end)
-            }
-        }
-    }
-
     /// Returns a slice of the string from the beginning to byte
     /// `end`.
     ///
@@ -1155,21 +1138,6 @@ mod traits {
         }
     }
 
-    /// Returns a mutable slice of the string from the beginning to byte
-    /// `end`.
-    #[stable(feature = "derefmut_for_string", since = "1.2.0")]
-    impl ops::IndexMut<ops::RangeTo<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
-            // is_char_boundary checks that the index is in [0, .len()]
-            if self.is_char_boundary(index.end) {
-                unsafe { self.slice_mut_unchecked(0, index.end) }
-            } else {
-                super::slice_error_fail(self, 0, index.end)
-            }
-        }
-    }
-
     /// Returns a slice of the string from `begin` to its end.
     ///
     /// Equivalent to `self[begin .. self.len()]`.
@@ -1191,21 +1159,6 @@ mod traits {
         }
     }
 
-    /// Returns a slice of the string from `begin` to its end.
-    #[stable(feature = "derefmut_for_string", since = "1.2.0")]
-    impl ops::IndexMut<ops::RangeFrom<usize>> for str {
-        #[inline]
-        fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
-            // is_char_boundary checks that the index is in [0, .len()]
-            if self.is_char_boundary(index.start) {
-                let len = self.len();
-                unsafe { self.slice_mut_unchecked(index.start, len) }
-            } else {
-                super::slice_error_fail(self, index.start, self.len())
-            }
-        }
-    }
-
     #[stable(feature = "rust1", since = "1.0.0")]
     impl ops::Index<ops::RangeFull> for str {
         type Output = str;
@@ -1215,14 +1168,6 @@ mod traits {
             self
         }
     }
-
-    #[stable(feature = "derefmut_for_string", since = "1.2.0")]
-    impl ops::IndexMut<ops::RangeFull> for str {
-        #[inline]
-        fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
-            self
-        }
-    }
 }
 
 /// Methods for string slices
@@ -1259,7 +1204,6 @@ pub trait StrExt {
     fn char_len(&self) -> usize;
     fn slice_chars<'a>(&'a self, begin: usize, end: usize) -> &'a str;
     unsafe fn slice_unchecked<'a>(&'a self, begin: usize, end: usize) -> &'a str;
-    unsafe fn slice_mut_unchecked<'a>(&'a mut self, begin: usize, end: usize) -> &'a mut str;
     fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool;
     fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
         where P::Searcher: ReverseSearcher<'a>;
@@ -1279,7 +1223,6 @@ pub trait StrExt {
         where P::Searcher: ReverseSearcher<'a>;
     fn find_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>;
     fn split_at(&self, mid: usize) -> (&str, &str);
-    fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str);
     fn slice_shift_char<'a>(&'a self) -> Option<(char, &'a str)>;
     fn subslice_offset(&self, inner: &str) -> usize;
     fn as_ptr(&self) -> *const u8;
@@ -1436,14 +1379,6 @@ impl StrExt for str {
         })
     }
 
-    #[inline]
-    unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str {
-        mem::transmute(Slice {
-            data: self.as_ptr().offset(begin as isize),
-            len: end - begin,
-        })
-    }
-
     #[inline]
     fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
         pat.is_prefix_of(self)
@@ -1592,20 +1527,6 @@ impl StrExt for str {
         }
     }
 
-    fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str) {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if self.is_char_boundary(mid) {
-            let len = self.len();
-            unsafe {
-                let self2: &mut str = mem::transmute_copy(&self);
-                (self.slice_mut_unchecked(0, mid),
-                 self2.slice_mut_unchecked(mid, len))
-            }
-        } else {
-            slice_error_fail(self, 0, mid)
-        }
-    }
-
     #[inline]
     fn slice_shift_char(&self) -> Option<(char, &str)> {
         if self.is_empty() {

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

@@ -128,9 +128,6 @@ code, pre {
     border-radius: 3px;
     padding: 0 0.2em;
 }
-.docblock pre code {
-    padding: 0;
-}
 pre {
     background-color: #F5F5F5;
     padding: 14px;