---

yaml
---
r: 274914
b: refs/heads/stable
c: 14e8af4
h: refs/heads/master

Author: Robin Kruppe

[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: 004c4b4b7d581f54365bc621a23106e970120f99
+refs/heads/stable: 14e8af410023a7de0ac46249f01288297c88388b
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/.gitignore

@@ -17,7 +17,6 @@
 *.elc
 *.epub
 *.exe
-*.pdb
 *.fn
 *.html
 *.kdev4

branches/stable/mk/cfg/i586-unknown-linux-gnu.mk

@@ -1071,8 +1071,7 @@ $(3)/test/run-make/%-$(1)-T-$(2)-H-$(3).ok: \
 	    $$(S) \
 	    $(3) \
 	    "$$(LLVM_LIBDIR_RUSTFLAGS_$(3))" \
-	    "$$(LLVM_ALL_COMPONENTS_$(3))" \
-	    "$$(LLVM_CXXFLAGS_$(3))"
+	    "$$(LLVM_ALL_COMPONENTS_$(3))"
 	@touch -r $$@.start_time $$@ && rm $$@.start_time
 else
 # FIXME #11094 - The above rule doesn't work right for multiple targets

branches/stable/mk/tests.mk

@@ -286,8 +286,6 @@ use std::sync::mpsc;
 fn main() {
     let data = Arc::new(Mutex::new(0));
 
-    // `tx` is the "transmitter" or "sender"
-    // `rx` is the "receiver"
     let (tx, rx) = mpsc::channel();
 
     for _ in 0..10 {

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

@@ -319,23 +319,23 @@ our source code:
 ```text
     First, we set `x` to five:
 
-    ```rust
+    ```text
     let x = 5;
     # let y = 6;
     # println!("{}", x + y);
     ```
 
     Next, we set `y` to six:
 
-    ```rust
+    ```text
     # let x = 5;
     let y = 6;
     # println!("{}", x + y);
     ```
 
     Finally, we print the sum of `x` and `y`:
 
-    ```rust
+    ```text
     # let x = 5;
     # let y = 6;
     println!("{}", x + y);

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

@@ -51,11 +51,10 @@ fn foo() {
 }
 ```
 
-When `v` comes into scope, a new [vector] is created on [the stack][stack],
-and it allocates space on [the heap][heap] for its elements. When `v` goes out
-of scope at the end of `foo()`, Rust will clean up everything related to the
-vector, even the heap-allocated memory. This happens deterministically, at the
-end of the scope.
+When `v` comes into scope, a new [vector] is created, and it allocates space on
+[the heap][heap] for each of its elements. When `v` goes out of scope at the
+end of `foo()`, Rust will clean up everything related to the vector, even the
+heap-allocated memory. This happens deterministically, at the end of the scope.
 
 We'll cover [vectors] in detail later in this chapter; we only use them
 here as an example of a type that allocates space on the heap at runtime. They
@@ -68,7 +67,6 @@ Vectors have a [generic type][generics] `Vec<T>`, so in this example `v` will ha
 [arrays]: primitive-types.html#arrays
 [vectors]: vectors.html
 [heap]: the-stack-and-the-heap.html
-[stack]: the-stack-and-the-heap.html#the-stack
 [bindings]: variable-bindings.html
 [generics]: generics.html
 

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

@@ -11,7 +11,7 @@ don’t want to use the standard library via an attribute: `#![no_std]`.
 > For details on binaries without the standard library, see [the nightly
 > chapter on `#![no_std]`](no-stdlib.html)
 
-To use `#![no_std]`, add it to your crate root:
+To use `#![no_std]`, add a it to your crate root:
 
 ```rust
 #![no_std]

branches/stable/src/doc/book/using-rust-without-the-standard-library.md

@@ -0,0 +1,2 @@
+\usepackage{newunicodechar}
+\newunicodechar⊥{{$\bot$}}

branches/stable/src/doc/uptack.tex

@@ -46,7 +46,6 @@ def convert_path_spec(name, value):
 putenv('RUSTC', os.path.abspath(sys.argv[3]))
 putenv('TMPDIR', os.path.abspath(sys.argv[4]))
 putenv('CC', sys.argv[5] + ' ' + sys.argv[6])
-putenv('CFLAGS', sys.argv[6])
 putenv('RUSTDOC', os.path.abspath(sys.argv[7]))
 filt = sys.argv[8]
 putenv('LD_LIB_PATH_ENVVAR', sys.argv[9])
@@ -56,7 +55,6 @@ def convert_path_spec(name, value):
 putenv('S', os.path.abspath(sys.argv[13]))
 putenv('RUSTFLAGS', sys.argv[15])
 putenv('LLVM_COMPONENTS', sys.argv[16])
-putenv('LLVM_CXXFLAGS', sys.argv[17])
 putenv('PYTHON', sys.executable)
 os.putenv('TARGET', target_triple)
 

branches/stable/src/etc/maketest.py

@@ -528,7 +528,7 @@ impl<T> Vec<T> {
     }
 
     /// Inserts an element at position `index` within the vector, shifting all
-    /// elements after it to the right.
+    /// elements after position `i` one position to the right.
     ///
     /// # Panics
     ///
@@ -570,7 +570,7 @@ impl<T> Vec<T> {
     }
 
     /// Removes and returns the element at position `index` within the vector,
-    /// shifting all elements after it to the left.
+    /// shifting all elements after position `index` one position to the left.
     ///
     /// # Panics
     ///

branches/stable/src/etc/regex-match-tests.py

@@ -741,13 +741,6 @@ macro_rules! int_impl {
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
         ///
-        /// Note that this is *not* the same as a rotate-left; the
-        /// RHS of a wrapping shift-left is restricted to the range
-        /// of the type, rather than the bits shifted out of the LHS
-        /// being returned to the other end. The primitive integer
-        /// types all implement a `rotate_left` function, which may
-        /// be what you want instead.
-        ///
         /// # Examples
         ///
         /// Basic usage:
@@ -766,13 +759,6 @@ macro_rules! int_impl {
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
         ///
-        /// Note that this is *not* the same as a rotate-right; the
-        /// RHS of a wrapping shift-right is restricted to the range
-        /// of the type, rather than the bits shifted out of the LHS
-        /// being returned to the other end. The primitive integer
-        /// types all implement a `rotate_right` function, which may
-        /// be what you want instead.
-        ///
         /// # Examples
         ///
         /// Basic usage:

branches/stable/src/libcollections/vec.rs

@@ -89,7 +89,6 @@ macro_rules! supported_targets {
 supported_targets! {
     ("x86_64-unknown-linux-gnu", x86_64_unknown_linux_gnu),
     ("i686-unknown-linux-gnu", i686_unknown_linux_gnu),
-    ("i586-unknown-linux-gnu", i586_unknown_linux_gnu),
     ("mips-unknown-linux-gnu", mips_unknown_linux_gnu),
     ("mipsel-unknown-linux-gnu", mipsel_unknown_linux_gnu),
     ("powerpc-unknown-linux-gnu", powerpc_unknown_linux_gnu),

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

@@ -913,29 +913,26 @@ pub fn lower_pat(lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
     P(hir::Pat {
         id: p.id,
         node: match p.node {
-            PatKind::Wild => hir::PatWild,
-            PatKind::Ident(ref binding_mode, pth1, ref sub) => {
+            PatWild => hir::PatWild,
+            PatIdent(ref binding_mode, pth1, ref sub) => {
                 hir::PatIdent(lower_binding_mode(lctx, binding_mode),
                               respan(pth1.span, lower_ident(lctx, pth1.node)),
                               sub.as_ref().map(|x| lower_pat(lctx, x)))
             }
-            PatKind::Lit(ref e) => hir::PatLit(lower_expr(lctx, e)),
-            PatKind::TupleStruct(ref pth, ref pats) => {
+            PatLit(ref e) => hir::PatLit(lower_expr(lctx, e)),
+            PatEnum(ref pth, ref pats) => {
                 hir::PatEnum(lower_path(lctx, pth),
                              pats.as_ref()
                                  .map(|pats| pats.iter().map(|x| lower_pat(lctx, x)).collect()))
             }
-            PatKind::Path(ref pth) => {
-                hir::PatEnum(lower_path(lctx, pth), Some(hir::HirVec::new()))
-            }
-            PatKind::QPath(ref qself, ref pth) => {
+            PatQPath(ref qself, ref pth) => {
                 let qself = hir::QSelf {
                     ty: lower_ty(lctx, &qself.ty),
                     position: qself.position,
                 };
                 hir::PatQPath(qself, lower_path(lctx, pth))
             }
-            PatKind::Struct(ref pth, ref fields, etc) => {
+            PatStruct(ref pth, ref fields, etc) => {
                 let pth = lower_path(lctx, pth);
                 let fs = fields.iter()
                                .map(|f| {
@@ -951,22 +948,20 @@ pub fn lower_pat(lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
                                .collect();
                 hir::PatStruct(pth, fs, etc)
             }
-            PatKind::Tup(ref elts) => {
-                hir::PatTup(elts.iter().map(|x| lower_pat(lctx, x)).collect())
-            }
-            PatKind::Box(ref inner) => hir::PatBox(lower_pat(lctx, inner)),
-            PatKind::Ref(ref inner, mutbl) => {
+            PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(lctx, x)).collect()),
+            PatBox(ref inner) => hir::PatBox(lower_pat(lctx, inner)),
+            PatRegion(ref inner, mutbl) => {
                 hir::PatRegion(lower_pat(lctx, inner), lower_mutability(lctx, mutbl))
             }
-            PatKind::Range(ref e1, ref e2) => {
+            PatRange(ref e1, ref e2) => {
                 hir::PatRange(lower_expr(lctx, e1), lower_expr(lctx, e2))
             }
-            PatKind::Vec(ref before, ref slice, ref after) => {
+            PatVec(ref before, ref slice, ref after) => {
                 hir::PatVec(before.iter().map(|x| lower_pat(lctx, x)).collect(),
                             slice.as_ref().map(|x| lower_pat(lctx, x)),
                             after.iter().map(|x| lower_pat(lctx, x)).collect())
             }
-            PatKind::Mac(_) => panic!("Shouldn't exist here"),
+            PatMac(_) => panic!("Shouldn't exist here"),
         },
         span: p.span,
     })