---

yaml
---
r: 212143
b: refs/heads/tmp
c: d136714
h: refs/heads/master
i:
  212141: 60f75ad
  212139: 226a4d4
  212135: 938a395
  212127: b13f3db
v: v3

Author: michaelwoerister

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 62e70d35be3fe532c26a400b499c58a18f18dd3a
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 48e9ef640480a5371759d011da7acbe2fa182511
+refs/heads/tmp: d136714e04fa244fb45a8459cb717dc682208697
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: b77d60adb019bb5de05e884a99f3290ec4694137
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/configure

@@ -565,7 +565,7 @@ opt rpath 0 "build rpaths into rustc itself"
 # This is used by the automation to produce single-target nightlies
 opt dist-host-only 0 "only install bins for the host architecture"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
-opt llvm-version-check 1 "check if the LLVM version is supported, build anyway"
+opt llvm-version-check 1 "don't check if the LLVM version is supported, build anyway"
 
 # Optimization and debugging options. These may be overridden by the release channel, etc.
 opt_nosave optimize 1 "build optimized rust code"
@@ -593,7 +593,6 @@ valopt musl-root "/usr/local" "MUSL root installation directory"
 opt_nosave manage-submodules 1 "let the build manage the git submodules"
 opt_nosave clang 0 "prefer clang to gcc for building the runtime"
 opt_nosave jemalloc 1 "build liballoc with jemalloc"
-opt elf-tls 1 "elf thread local storage on platforms where supported"
 
 valopt_nosave prefix "/usr/local" "set installation prefix"
 valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary"

branches/tmp/mk/cfg/x86_64-pc-windows-msvc.mk

@@ -80,8 +80,3 @@ CUSTOM_DEPS_rustc_llvm_T_x86_64-pc-windows-msvc += \
 x86_64-pc-windows-msvc/rt/rustc_llvm.def: $(S)src/etc/mklldef.py \
 			$(S)src/librustc_llvm/lib.rs
 	$(CFG_PYTHON) $^ $@ rustc_llvm-$(CFG_FILENAME_EXTRA)
-
-# All windows nightiles are currently a GNU triple, so this MSVC triple is not
-# bootstrapping from itself. This is relevant during stage0, and other parts of
-# the build system take this into account.
-BOOTSTRAP_FROM_x86_64-pc-windows-msvc := x86_64-pc-windows-gnu

branches/tmp/mk/crates.mk

@@ -150,7 +150,3 @@ TOOL_INPUTS_$(1) := $$(call rwildcard,$$(dir $$(TOOL_SOURCE_$(1))),*.rs)
 endef
 
 $(foreach crate,$(TOOLS),$(eval $(call RUST_TOOL,$(crate))))
-
-ifdef CFG_DISABLE_ELF_TLS
-RUSTFLAGS_std := --cfg no_elf_tls
-endif

branches/tmp/mk/debuggers.mk

@@ -15,7 +15,8 @@
 
 ## GDB ##
 DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB=gdb_load_rust_pretty_printers.py \
-                                 gdb_rust_pretty_printing.py
+                                 gdb_rust_pretty_printing.py \
+                                 debugger_pretty_printers_common.py
 DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS=\
     $(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB), \
         $(CFG_SRC_DIR)src/etc/$(script))
@@ -27,7 +28,8 @@ DEBUGGER_BIN_SCRIPTS_GDB_ABS=\
 
 
 ## LLDB ##
-DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB=lldb_rust_formatters.py
+DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB=lldb_rust_formatters.py \
+                                  debugger_pretty_printers_common.py
 DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS=\
     $(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB), \
         $(CFG_SRC_DIR)src/etc/$(script))

branches/tmp/mk/main.mk

@@ -74,6 +74,9 @@ ifneq ($(wildcard $(subst $(SPACE),\$(SPACE),$(CFG_GIT_DIR))),)
 endif
 endif
 
+CFG_BUILD_DATE = $(shell date +%F)
+CFG_VERSION += (built $(CFG_BUILD_DATE))
+
 # Windows exe's need numeric versions - don't use anything but
 # numbers and dots here
 CFG_VERSION_WIN = $(CFG_RELEASE_NUM)
@@ -127,7 +130,9 @@ CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
 
 ifdef CFG_ENABLE_DEBUG_ASSERTIONS
   $(info cfg: enabling debug assertions (CFG_ENABLE_DEBUG_ASSERTIONS))
-  CFG_RUSTC_FLAGS += -C debug-assertions=on
+  CFG_RUSTC_FLAGS += --cfg debug -C debug-assertions=on
+else
+  CFG_RUSTC_FLAGS += --cfg ndebug
 endif
 
 ifdef CFG_ENABLE_DEBUGINFO
@@ -329,6 +334,7 @@ endif
 ifdef CFG_VER_HASH
 export CFG_VER_HASH
 endif
+export CFG_BUILD_DATE
 export CFG_VERSION
 export CFG_VERSION_WIN
 export CFG_RELEASE

branches/tmp/mk/target.mk

@@ -181,42 +181,3 @@ $(foreach host,$(CFG_HOST), \
   $(foreach stage,$(STAGES), \
    $(foreach tool,$(TOOLS), \
     $(eval $(call TARGET_TOOL,$(stage),$(target),$(host),$(tool)))))))
-
-# We have some triples which are bootstrapped from other triples, and this means
-# that we need to fixup some of the native tools that a triple depends on.
-#
-# For example, MSVC requires the llvm-ar.exe executable to manage archives, but
-# it bootstraps from the GNU Windows triple. This means that the compiler will
-# add this directory to PATH when executing new processes:
-#
-# 	$SYSROOT/rustlib/x86_64-pc-windows-gnu/bin
-#
-# Unfortunately, however, the GNU triple is not known about in stage0, so the
-# tools are actually located in:
-#
-# 	$SYSROOT/rustlib/x86_64-pc-windows-msvc/bin
-#
-# To remedy this problem, the rules below copy all native tool dependencies into
-# the bootstrap triple's location in stage 0 so the bootstrap compiler can find
-# the right sets of tools. Later stages (1+) will have the right host triple for
-# the compiler, so there's no need to worry there.
-#
-# $(1) - stage
-# $(2) - triple that's being used as host/target
-# $(3) - triple snapshot is built for
-# $(4) - crate
-# $(5) - tool
-define MOVE_TOOLS_TO_SNAPSHOT_HOST_DIR
-ifneq (,$(3))
-$$(TLIB$(1)_T_$(2)_H_$(2))/stamp.$(4): $$(HLIB$(1)_H_$(2))/rustlib/$(3)/bin/$(5)
-
-$$(HLIB$(1)_H_$(2))/rustlib/$(3)/bin/$(5): $$(TBIN$(1)_T_$(2)_H_$(2))/$(5)
-	mkdir -p $$(@D)
-	cp $$< $$@
-endif
-endef
-
-$(foreach target,$(CFG_TARGET), \
- $(foreach crate,$(CRATES), \
-  $(foreach tool,$(NATIVE_TOOL_DEPS_$(crate)_T_$(target)), \
-   $(eval $(call MOVE_TOOLS_TO_SNAPSHOT_HOST_DIR,0,$(target),$(BOOTSTRAP_FROM_$(target)),$(crate),$(tool))))))

branches/tmp/mk/tests.mk

@@ -172,24 +172,23 @@ check: check-sanitycheck cleantmptestlogs cleantestlibs all check-stage2 tidy
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # As above but don't bother running tidy.
-check-notidy: check-sanitycheck cleantmptestlogs cleantestlibs all check-stage2
+check-notidy: cleantmptestlogs cleantestlibs all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # A slightly smaller set of tests for smoke testing.
-check-lite: check-sanitycheck cleantestlibs cleantmptestlogs \
+check-lite: cleantestlibs cleantmptestlogs \
 	$(foreach crate,$(TEST_TARGET_CRATES),check-stage2-$(crate)) \
 	check-stage2-rpass check-stage2-rpass-valgrind \
 	check-stage2-rfail check-stage2-cfail check-stage2-pfail check-stage2-rmake
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # Only check the 'reference' tests: rpass/cfail/rfail/rmake.
-check-ref: check-sanitycheck cleantestlibs cleantmptestlogs check-stage2-rpass \
-	check-stage2-rpass-valgrind check-stage2-rfail check-stage2-cfail check-stage2-pfail \
-	check-stage2-rmake
+check-ref: cleantestlibs cleantmptestlogs check-stage2-rpass check-stage2-rpass-valgrind \
+	check-stage2-rfail check-stage2-cfail check-stage2-pfail check-stage2-rmake
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # Only check the docs.
-check-docs: check-sanitycheck cleantestlibs cleantmptestlogs check-stage2-docs
+check-docs: cleantestlibs cleantmptestlogs check-stage2-docs
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # Some less critical tests that are not prone to breakage.

branches/tmp/src/doc/index.md

@@ -86,14 +86,3 @@ something if you know its name.
 
 If you encounter an error while compiling your code you may be able to look it
 up in the [Rust Compiler Error Index](error-index.html).
-
-# Community Translations
-
-Several projects have been started to translate the documentation into other
-languages:
-
-- [Russian](https://github.com/kgv/rust_book_ru)
-- [Korean](https://github.com/rust-kr/doc.rust-kr.org)
-- [Chinese](https://github.com/KaiserY/rust-book-chinese)
-- [Spanish](https://github.com/goyox86/elpr)
-

branches/tmp/src/doc/trpl/guessing-game.md

@@ -38,7 +38,7 @@ Finally, Cargo generated a ‘Hello, world!’ for us. Check out `src/main.rs`:
 
 ```rust
 fn main() {
-    println!("Hello, world!");
+    println!("Hello, world!")
 }
 ```
 
@@ -362,7 +362,7 @@ everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
 crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
 Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use the latest version we could use `*` or we could use a range
+numbers. If we wanted to use the latest version we could use `*` or we could use a range 
 of versions. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org

branches/tmp/src/doc/trpl/installing-rust.md

@@ -2,12 +2,8 @@
 
 The first step to using Rust is to install it! There are a number of ways to
 install Rust, but the easiest is to use the `rustup` script. If you're on Linux
-or a Mac, all you need to do is this: 
-
-> Note: you don't need to type in the `$`s, they just indicate the start of
-> each command. You’ll see many tutorials and examples around the web that
-> follow this convention: `$` for commands run as your regular user, and
-> `#` for commands you should be running as an administrator.
+or a Mac, all you need to do is this (note that you don't need to type in the
+`$`s, they just indicate the start of each command):
 
 ```bash
 $ curl -sf -L https://static.rust-lang.org/rustup.sh | sh

branches/tmp/src/doc/trpl/iterators.md

@@ -213,7 +213,7 @@ As we've said before, an iterator is something that we can call the
 `.next()` method on repeatedly, and it gives us a sequence of things.
 Because you need to call the method, this means that iterators
 can be *lazy* and not generate all of the values upfront. This code,
-for example, does not actually generate the numbers `1-99`, instead
+for example, does not actually generate the numbers `1-100`, instead
 creating a value that merely represents the sequence:
 
 ```rust
@@ -321,7 +321,7 @@ You can chain all three things together: start with an iterator, adapt it
 a few times, and then consume the result. Check it out:
 
 ```rust
-(1..)
+(1..1000)
     .filter(|&x| x % 2 == 0)
     .filter(|&x| x % 3 == 0)
     .take(5)

branches/tmp/src/doc/trpl/mutability.md

@@ -89,7 +89,7 @@ philosophy, memory safety, and the mechanism by which Rust guarantees it, the
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html
-[borrowing]: references-and-borrowing.html#borrowing
+[borrowing]: borrowing.html#The-Rules
 
 So, that’s the real definition of ‘immutability’: is this safe to have two
 pointers to? In `Arc<T>`’s case, yes: the mutation is entirely contained inside

branches/tmp/src/doc/trpl/raw-pointers.md

@@ -77,7 +77,7 @@ For more operations on raw pointers, see [their API documentation][rawapi].
 # FFI
 
 Raw pointers are useful for FFI: Rust’s `*const T` and `*mut T` are similar to
-C’s `const T*` and `T*`, respectively. For more about this use, consult the
+C’s `const T*` and `T*`, respectfully. For more about this use, consult the
 [FFI chapter][ffi].
 
 [ffi]: ffi.html

branches/tmp/src/etc/check-sanitycheck.py

@@ -11,18 +11,19 @@
 # except according to those terms.
 
 import os
-import subprocess
 import sys
 import functools
 
 STATUS = 0
 
+
 def error_unless_permitted(env_var, message):
     global STATUS
     if not os.getenv(env_var):
         sys.stderr.write(message)
         STATUS = 1
 
+
 def only_on(platforms):
     def decorator(func):
         @functools.wraps(func)
@@ -32,7 +33,8 @@ def inner():
         return inner
     return decorator
 
-@only_on(['linux', 'darwin', 'freebsd', 'openbsd'])
+
+@only_on(('linux', 'darwin', 'freebsd', 'openbsd'))
 def check_rlimit_core():
     import resource
     soft, hard = resource.getrlimit(resource.RLIMIT_CORE)
@@ -43,14 +45,8 @@ def check_rlimit_core():
 set ALLOW_NONZERO_RLIMIT_CORE to ignore this warning
 """ % (soft))
 
-@only_on(['win32'])
-def check_console_code_page():
-    if '65001' not in subprocess.check_output(['cmd', '/c', 'chcp']):
-        sys.stderr.write('Warning: the console output code page is not UTF-8, \
-some tests may fail. Use `cmd /c "chcp 65001"` to setup UTF-8 code page.\n')
 
 def main():
-    check_console_code_page()
     check_rlimit_core()
 
 if __name__ == '__main__':