---

yaml
---
r: 274981
b: refs/heads/stable
c: 271777c
h: refs/heads/master
i:
  274979: 3040621

Author: wesleywiser

[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: 94ecd483e5ed692a6424b882b706e6615efa8336
+refs/heads/stable: 271777ce2214652bc75964c3b4953f08d0fdfbe2
 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/README.md

@@ -17,7 +17,7 @@ Read ["Installing Rust"] from [The Book].
 1. Make sure you have installed the dependencies:
 
    * `g++` 4.7 or `clang++` 3.x
-   * `python` 2.7 (but not 3.x)
+   * `python` 2.7 or later (but not 3.x)
    * GNU `make` 3.81 or later
    * `curl`
    * `git`

branches/stable/configure

@@ -729,12 +729,12 @@ step_msg "looking for build programs"
 
 probe_need CFG_CURLORWGET  curl wget
 if [ -z "$CFG_PYTHON_PROVIDED" ]; then
-    probe_need CFG_PYTHON      python2.7 python2 python
+    probe_need CFG_PYTHON      python2.7 python2.6 python2 python
 fi
 
 python_version=$($CFG_PYTHON -V 2>&1)
-if [ $(echo $python_version | grep -c '^Python 2\.7') -ne 1 ]; then
-    err "Found $python_version, but Python 2.7 is required"
+if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
+    err "Found $python_version, but LLVM requires Python 2.4-2.7"
 fi
 
 # If we have no git directory then we are probably a tarball distribution

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

@@ -59,7 +59,7 @@ RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
                 rustc_plugin rustc_metadata rustc_passes
 HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros
-TOOLS := compiletest rustdoc rustc rustbook error_index_generator
+TOOLS := compiletest rustdoc rustc rustbook error-index-generator
 
 DEPS_core :=
 DEPS_alloc := core libc alloc_system
@@ -120,12 +120,12 @@ TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc
-TOOL_DEPS_error_index_generator := rustdoc syntax serialize
+TOOL_DEPS_error-index-generator := rustdoc syntax serialize
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustbook := $(S)src/rustbook/main.rs
-TOOL_SOURCE_error_index_generator := $(S)src/error_index_generator/main.rs
+TOOL_SOURCE_error-index-generator := $(S)src/error-index-generator/main.rs
 
 ONLY_RLIB_core := 1
 ONLY_RLIB_libc := 1

branches/stable/mk/crates.mk

@@ -52,7 +52,7 @@ PKG_FILES := \
       doc                                      \
       driver                                   \
       etc                                      \
-      error_index_generator                    \
+      error-index-generator                    \
       $(foreach crate,$(CRATES),lib$(crate))   \
       libcollectionstest                       \
       libcoretest                              \

branches/stable/mk/dist.mk

@@ -59,8 +59,8 @@ RUSTBOOK_EXE = $(HBIN2_H_$(CFG_BUILD))/rustbook$(X_$(CFG_BUILD))
 # ./configure
 RUSTBOOK = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(RUSTBOOK_EXE)
 
-# The error_index_generator executable...
-ERR_IDX_GEN_EXE = $(HBIN2_H_$(CFG_BUILD))/error_index_generator$(X_$(CFG_BUILD))
+# The error-index-generator executable...
+ERR_IDX_GEN_EXE = $(HBIN2_H_$(CFG_BUILD))/error-index-generator$(X_$(CFG_BUILD))
 ERR_IDX_GEN = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE)
 ERR_IDX_GEN_MD = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE) markdown
 
@@ -221,9 +221,9 @@ error-index: doc/error-index.html
 # Metadata used to generate the index is created as a side effect of
 # the build so this depends on every crate being up to date.
 doc/error-index.html: $(ERR_IDX_GEN_EXE) $(CSREQ$(2)_T_$(CFG_BUILD)_H_$(CFG_BUILD)) | doc/
-	$(Q)$(call E, error_index_generator: $@)
+	$(Q)$(call E, error-index-generator: $@)
 	$(Q)$(ERR_IDX_GEN)
 
 doc/error-index.md: $(ERR_IDX_GEN_EXE) $(CSREQ$(2)_T_$(CFG_BUILD)_H_$(CFG_BUILD)) | doc/
-	$(Q)$(call E, error_index_generator: $@)
+	$(Q)$(call E, error-index-generator: $@)
 	$(Q)$(ERR_IDX_GEN_MD)

branches/stable/mk/docs.mk

@@ -82,7 +82,7 @@ define PREPARE_MAN
 
 endef
 
-PREPARE_TOOLS = $(filter-out compiletest rustbook error_index_generator, $(TOOLS))
+PREPARE_TOOLS = $(filter-out compiletest rustbook error-index-generator, $(TOOLS))
 
 
 # $(1) is tool

branches/stable/mk/prepare.mk

@@ -148,15 +148,7 @@ ifeq ($$(CFG_WINDOWSY_$(1)),1)
 else ifeq ($(OSTYPE_$(1)), apple-ios)
   JEMALLOC_ARGS_$(1) := --disable-tls
 else ifeq ($(findstring android, $(OSTYPE_$(1))), android)
-  # We force android to have prefixed symbols because apparently replacement of
-  # the libc allocator doesn't quite work. When this was tested (unprefixed
-  # symbols), it was found that the `realpath` function in libc would allocate
-  # with libc malloc (not jemalloc malloc), and then the standard library would
-  # free with jemalloc free, causing a segfault.
-  #
-  # If the test suite passes, however, without symbol prefixes then we should be
-  # good to go!
-  JEMALLOC_ARGS_$(1) := --disable-tls --with-jemalloc-prefix=je_
+  JEMALLOC_ARGS_$(1) := --disable-tls
 endif
 
 ifdef CFG_ENABLE_DEBUG_JEMALLOC
@@ -194,7 +186,7 @@ JEMALLOC_LOCAL_$(1) := $$(JEMALLOC_BUILD_DIR_$(1))/lib/$$(JEMALLOC_REAL_NAME_$(1
 $$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, make: jemalloc)
 	cd "$$(JEMALLOC_BUILD_DIR_$(1))"; "$(S)src/jemalloc/configure" \
-		$$(JEMALLOC_ARGS_$(1)) $(CFG_JEMALLOC_FLAGS) \
+		$$(JEMALLOC_ARGS_$(1)) --with-jemalloc-prefix=je_ $(CFG_JEMALLOC_FLAGS) \
 		--build=$$(CFG_GNU_TRIPLE_$(CFG_BUILD)) --host=$$(CFG_GNU_TRIPLE_$(1)) \
 		CC="$$(CC_$(1)) $$(CFG_JEMALLOC_CFLAGS_$(1))" \
 		AR="$$(AR_$(1))" \

branches/stable/mk/rt.mk

@@ -1071,9 +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))" \
-	    '$$(CXX_$(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

@@ -68,7 +68,7 @@ You get this error:
 
 ```text
 expected one of `!`, `:`, or `@`, found `)`
-fn print_sum(x, y) {
+fn print_number(x, y) {
 ```
 
 This is a deliberate design decision. While full-program inference is possible,

branches/stable/src/doc/book/functions.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

@@ -39,7 +39,7 @@ The second, with a `\`, trims the spaces and the newline:
 
 ```rust
 let s = "foo\
-    bar";
+    bar"; 
 
 assert_eq!("foobar", s);
 ```

branches/stable/src/doc/book/strings.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

@@ -11,21 +11,15 @@ let v = vec![1, 2, 3, 4, 5]; // v: Vec<i32>
 ```
 
 (Notice that unlike the `println!` macro we’ve used in the past, we use square
-brackets `[]` with `vec!` macro. Rust allows you to use either in either
-situation, this is just convention.)
+brackets `[]` with `vec!` macro. Rust allows you to use either in either situation,
+this is just convention.)
 
 There’s an alternate form of `vec!` for repeating an initial value:
 
 ```rust
 let v = vec![0; 10]; // ten zeroes
 ```
 
-Vectors store their contents as contiguous arrays of `T` on the heap. This means
-that they must be able to know the size of `T` at compile time (that is, how
-many bytes are needed to store a `T`?). The size of some things can't be known
-at compile time. For these you'll have to store a pointer to that thing:
-thankfully, the [`Box`][box] type works perfectly for this.
-
 ## Accessing elements
 
 To get the value at a particular index in the vector, we use `[]`s:
@@ -119,7 +113,6 @@ Vectors have many more useful methods, which you can read about in [their
 API documentation][vec].
 
 [vec]: ../std/vec/index.html
-[box]: ../std/boxed/index.html
 [generic]: generics.html
 [panic]: concurrency.html#panics
 [get]: http://doc.rust-lang.org/std/vec/struct.Vec.html#method.get

branches/stable/src/doc/book/vectors.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,8 +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('CXX', sys.argv[18])
 putenv('PYTHON', sys.executable)
 os.putenv('TARGET', target_triple)