---

yaml
---
r: 138331
b: refs/heads/auto
c: d670919
h: refs/heads/master
i:
  138329: 191f611
  138327: d57c8ec
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 7876cf9ca915724d1888043a9cbfedd45009e5f2
+refs/heads/auto: d670919aa43d186317a89a375f4a5b7170fc08a8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/README.md

@@ -10,11 +10,10 @@ documentation.
 3. Enjoy!
 
 > ***Note:*** Windows users can read the detailed
-> [getting started][wiki-start] notes on the wiki.
+> [using Rust on Windows][win-wiki] notes on the wiki.
 
 [installer]: http://www.rust-lang.org/install.html
 [guide]: http://doc.rust-lang.org/guide.html
-[wiki-start]: https://github.com/rust-lang/rust/wiki/Note-getting-started-developing-Rust
 [win-wiki]: https://github.com/rust-lang/rust/wiki/Using-Rust-on-Windows
 
 ## Building from Source
@@ -87,7 +86,7 @@ fetch snapshots, and an OS that can execute the available snapshot binaries.
 
 Snapshot binaries are currently built and tested on several platforms:
 
-* Windows (7, 8, Server 2008 R2), x86 only
+* Windows (7, 8, Server 2008 R2), x86 and x86-64 (64-bit support added in Rust 0.12.0)
 * Linux (2.6.18 or later, various distributions), x86 and x86-64
 * OSX 10.7 (Lion) or greater, x86 and x86-64
 

branches/auto/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rbml rlibc alloc debug rustrt \
+                 url log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
@@ -63,20 +63,19 @@ DEPS_libc := core
 DEPS_rlibc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
-DEPS_debug := std
 DEPS_rustrt := alloc core libc collections native:rustrt_native
 DEPS_std := core libc rand alloc collections rustrt sync unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_native := std
-DEPS_syntax := std term serialize log fmt_macros debug arena libc
+DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
-              time log graphviz debug rustc_llvm rustc_back
+              time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustdoc := rustc native:hoedown serialize getopts \
-                test time debug
+                test time
 DEPS_flate := std native:miniz
 DEPS_arena := std
 DEPS_graphviz := std

branches/auto/mk/install.mk

@@ -14,16 +14,34 @@ else
 MAYBE_DISABLE_VERIFY=
 endif
 
-install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
+install:
+ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
+# Build the dist as the original user
+	$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_install
+else
+	$(Q)$(MAKE) prepare_install
+endif
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
-# Remove tmp files while we can because they may have been created under sudo
+# Remove tmp files because it's a decent amount of disk space
 	$(Q)rm -R tmp/dist
 
-uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
+prepare_install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
+
+uninstall:
+ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
+# Build the dist as the original user
+	$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_uninstall
+else
+	$(Q)$(MAKE) prepare_uninstall
+endif
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
-# Remove tmp files while we can because they may have been created under sudo
+# Remove tmp files because it's a decent amount of disk space
 	$(Q)rm -R tmp/dist
 
+prepare_uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
+
+.PHONY: install prepare_install uninstall prepare_uninstall
+
 tmp/empty_dir:
 	mkdir -p $@
 

branches/auto/mk/tests.mk

@@ -199,14 +199,29 @@ check-docs: cleantestlibs cleantmptestlogs check-stage2-docs
 
 # Some less critical tests that are not prone to breakage.
 # Not run as part of the normal test suite, but tested by bors on checkin.
-check-secondary: check-lexer check-pretty
+check-secondary: check-build-compiletest check-lexer check-pretty
 
 # check + check-secondary.
-check-all: check check-secondary
+#
+# Issue #17883: build check-secondary first so hidden dependencies in
+# e.g. building compiletest are exercised (resolve those by adding
+# deps to rules that need them; not by putting `check` first here).
+check-all: check-secondary check
 
 # Pretty-printing tests.
 check-pretty: check-stage2-T-$(CFG_BUILD)-H-$(CFG_BUILD)-pretty-exec
 
+define DEF_CHECK_BUILD_COMPILETEST_FOR_STAGE
+check-stage$(1)-build-compiletest: 	$$(HBIN$(1)_H_$(CFG_BUILD))/compiletest$$(X_$(CFG_BUILD))
+endef
+
+$(foreach stage,$(STAGES), \
+ $(eval $(call DEF_CHECK_BUILD_COMPILETEST_FOR_STAGE,$(stage))))
+
+check-build-compiletest: \
+	check-stage1-build-compiletest \
+	check-stage2-build-compiletest
+
 .PHONY: cleantmptestlogs cleantestlibs
 
 cleantmptestlogs:
@@ -284,7 +299,7 @@ tidy:
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)echo $(ALL_HS) \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
-		$(Q)find $(S)src -type f -perm a+x \
+		$(Q)find $(S)src -type f -perm +a+x \
 		    -not -name '*.rs' -and -not -name '*.py' \
 		    -and -not -name '*.sh' \
 		| grep '^$(S)src/jemalloc' -v \
@@ -720,6 +735,13 @@ PRETTY_DEPS_pretty-rpass-full = $(RPASS_FULL_TESTS)
 PRETTY_DEPS_pretty-rfail = $(RFAIL_TESTS)
 PRETTY_DEPS_pretty-bench = $(BENCH_TESTS)
 PRETTY_DEPS_pretty-pretty = $(PRETTY_TESTS)
+# The stage- and host-specific dependencies are for e.g. macro_crate_test which pulls in
+# external crates.
+PRETTY_DEPS$(1)_H_$(3)_pretty-rpass =
+PRETTY_DEPS$(1)_H_$(3)_pretty-rpass-full = $$(HLIB$(1)_H_$(3))/stamp.syntax $$(HLIB$(1)_H_$(3))/stamp.rustc
+PRETTY_DEPS$(1)_H_$(3)_pretty-rfail =
+PRETTY_DEPS$(1)_H_$(3)_pretty-bench =
+PRETTY_DEPS$(1)_H_$(3)_pretty-pretty =
 PRETTY_DIRNAME_pretty-rpass = run-pass
 PRETTY_DIRNAME_pretty-rpass-full = run-pass-fulldeps
 PRETTY_DIRNAME_pretty-rfail = run-fail
@@ -738,7 +760,8 @@ check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4
 
 $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 	        $$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
-	        $$(PRETTY_DEPS_$(4))
+	        $$(PRETTY_DEPS_$(4)) \
+	        $$(PRETTY_DEPS$(1)_H_$(3)_$(4))
 	@$$(call E, run pretty-rpass [$(2)]: $$<)
 	$$(Q)$$(call CFG_RUN_CTEST_$(2),$(1),$$<,$(3)) \
 		$$(PRETTY_ARGS$(1)-T-$(2)-H-$(3)-$(4)) \

branches/auto/src/compiletest/errors.rs

@@ -31,7 +31,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
-        let kind = caps.name("kind").to_ascii().to_lower().into_string();
+        let kind = caps.name("kind").to_ascii().to_lowercase().into_string();
         let msg = caps.name("msg").trim().to_string();
 
         debug!("line={} kind={} msg={}", line_num, kind, msg);

branches/auto/src/compiletest/runtest.rs

@@ -947,15 +947,12 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         String::from_chars(c.as_slice())
     }
 
-    #[cfg(target_os = "windows")]
+    #[cfg(windows)]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
 
-    #[cfg(any(target_os = "linux",
-              target_os = "macos",
-              target_os = "freebsd",
-              target_os = "dragonfly"))]
+    #[cfg(unix)]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         line.starts_with( prefix )
     }
@@ -1356,24 +1353,21 @@ fn program_output(config: &Config, testfile: &Path, lib_path: &str, prog: String
 }
 
 // Linux and mac don't require adjusting the library search path
-#[cfg(any(target_os = "linux",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "dragonfly"))]
+#[cfg(unix)]
 fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {}", prog, args.connect(" "))
 }
 
-#[cfg(target_os = "windows")]
+#[cfg(windows)]
 fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
-    format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
-}
 
-// Build the LD_LIBRARY_PATH variable as it would be seen on the command line
-// for diagnostic purposes
-#[cfg(target_os = "windows")]
-fn lib_path_cmd_prefix(path: &str) -> String {
-    format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
+    // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
+    // for diagnostic purposes
+    fn lib_path_cmd_prefix(path: &str) -> String {
+        format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
+    }
+
+    format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
 }
 
 fn dump_output(config: &Config, testfile: &Path, out: &str, err: &str) {

branches/auto/src/doc/README.md

@@ -1,4 +1,6 @@
-# Dependencies
+# Rust documentations
+
+## Dependencies
 
 [Pandoc](http://johnmacfarlane.net/pandoc/installing.html), a universal
 document converter, is required to generate docs as HTML from Rust's
@@ -10,7 +12,7 @@ docs from the master (English) docs.
 [GNU gettext](http://www.gnu.org/software/gettext/) is required for managing
 the translation data.
 
-# Building
+## Building
 
 To generate all the docs, just run `make docs` from the root of the repository.
 This will convert the distributed Markdown docs to HTML and generate HTML doc
@@ -24,7 +26,7 @@ rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 
 (This, of course, requires a working build of the `rustdoc` tool.)
 
-# Additional notes
+## Additional notes
 
 To generate an HTML version of a doc from Markdown manually, you can do
 something like:
@@ -33,37 +35,39 @@ something like:
 pandoc --from=markdown --to=html5 --number-sections -o reference.html reference.md
 ~~~~
 
-(reference.md being the Rust Reference Manual.)
+(`reference.md` being the Rust Reference Manual.)
 
 The syntax for pandoc flavored markdown can be found at:
-http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown
+
+- http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown
 
 A nice quick reference (for non-pandoc markdown) is at:
-http://kramdown.rubyforge.org/quickref.html
 
-# Notes for translators
+- http://kramdown.gettalong.org/quickref.html
+
+## Notes for translators
 
 Notice: The procedure described below is a work in progress. We are working on
 translation system but the procedure contains some manual operations for now.
 
-To start the translation for a new language, see po4a.conf at first.
+To start the translation for a new language, see `po4a.conf` at first.
 
-To generate .pot and .po files, do something like:
+To generate `.pot` and `.po` files, do something like:
 
 ~~~~
 po4a --copyright-holder="The Rust Project Developers" \
     --package-name="Rust" \
-    --package-version="0.11.0" \
+    --package-version="0.13.0" \
     -M UTF-8 -L UTF-8 \
     src/doc/po4a.conf
 ~~~~
 
-(the version number must be changed if it is not 0.11.0 now.)
+(the version number must be changed if it is not `0.13.0` now.)
 
-Now you can translate documents with .po files, commonly used with gettext. If
+Now you can translate documents with `.po` files, commonly used with gettext. If
 you are not familiar with gettext-based translation, please read the online
 manual linked from http://www.gnu.org/software/gettext/ . We use UTF-8 as the
-file encoding of .po files.
+file encoding of `.po` files.
 
 When you want to make a commit, do the command below before staging your
 change:
@@ -79,4 +83,4 @@ for f in src/doc/po/**/*.po; do
 done
 ~~~~
 
-This removes untranslated entries from .po files to save disk space.
+This removes untranslated entries from `.po` files to save disk space.

branches/auto/src/doc/guide-ffi.md

@@ -298,7 +298,7 @@ fn main() {
 C code:
 
 ~~~~c
-typedef void (*rust_callback)(int32_t);
+typedef void (*rust_callback)(void*, int32_t);
 void* cb_target;
 rust_callback cb;
 

branches/auto/src/doc/guide-strings.md

@@ -206,5 +206,5 @@ Many more bytes than graphemes!
 
 # Other Documentation
 
-* [the `&str` API documentation](/std/str/index.html)
+* [the `&str` API documentation](std/str/index.html)
 * [the `String` API documentation](std/string/index.html)

branches/auto/src/doc/guide-tasks.md

@@ -41,7 +41,7 @@ concurrency: particularly, ownership. The language leaves the implementation
 details to the standard library.
 
 The `spawn` function has a very simple type signature: `fn spawn(f: proc():
-Send)`.  Because it accepts only procs, and procs contain only owned data,
+Send)`. Because it accepts only procs, and procs contain only owned data,
 `spawn` can safely move the entire proc and all its associated state into an
 entirely different task for execution. Like any closure, the function passed to
 `spawn` may capture an environment that it carries across tasks.
@@ -213,7 +213,7 @@ println!("fib(50) = {}", delayed_fib.get())
 # }
 ```
 
-The call to `future::spawn` returns immediately a `future` object regardless of
+The call to `future::spawn` immediately returns a `future` object regardless of
 how long it takes to run `fib(50)`. You can then make yourself a sandwich while
 the computation of `fib` is running. The result of the execution of the method
 is obtained by calling `get` on the future. This call will block until the
@@ -297,7 +297,7 @@ let numbers_arc = Arc::new(numbers);
 ```
 
 and a clone is captured for each task via a procedure. This only copies
-the wrapper and not it's contents. Within the task's procedure, the captured
+the wrapper and not its contents. Within the task's procedure, the captured
 Arc reference can be used as a shared reference to the underlying vector as
 if it were local.
 
@@ -323,20 +323,20 @@ Rust has a built-in mechanism for raising exceptions. The `fail!()` macro
 (which can also be written with an error string as an argument: `fail!(
 ~reason)`) and the `assert!` construct (which effectively calls `fail!()` if a
 boolean expression is false) are both ways to raise exceptions. When a task
-raises an exception the task unwinds its stack---running destructors and
-freeing memory along the way---and then exits. Unlike exceptions in C++,
+raises an exception, the task unwinds its stack—running destructors and
+freeing memory along the way—and then exits. Unlike exceptions in C++,
 exceptions in Rust are unrecoverable within a single task: once a task fails,
 there is no way to "catch" the exception.
 
 While it isn't possible for a task to recover from failure, tasks may notify
 each other of failure. The simplest way of handling task failure is with the
-`try` function, which is similar to `spawn`, but immediately blocks waiting for
-the child task to finish. `try` returns a value of type `Result<T, Box<Any +
-Send>>`.  `Result` is an `enum` type with two variants: `Ok` and `Err`. In this
-case, because the type arguments to `Result` are `int` and `()`, callers can
-pattern-match on a result to check whether it's an `Ok` result with an `int`
-field (representing a successful result) or an `Err` result (representing
-termination with an error).
+`try` function, which is similar to `spawn`, but immediately blocks and waits
+for the child task to finish. `try` returns a value of type
+`Result<T, Box<Any + Send>>`. `Result` is an `enum` type with two variants:
+`Ok` and `Err`. In this case, because the type arguments to `Result` are `int`
+and `()`, callers can pattern-match on a result to check whether it's an `Ok`
+result with an `int` field (representing a successful result) or an `Err` result
+(representing termination with an error).
 
 ```{rust}
 # use std::task;
@@ -369,4 +369,4 @@ the entire program (perhaps you're writing an assert which, if it trips,
 indicates an unrecoverable logic error); in other cases you might want to
 contain the failure at a certain boundary (perhaps a small piece of input from
 the outside world, which you happen to be processing in parallel, is malformed
-and its processing task can't proceed).
+such that the processing task cannot proceed).