---

yaml
---
r: 110193
b: refs/heads/auto
c: 02c81fe
h: refs/heads/master
i:
  110191: f511be4
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: b78ac5b74a62e7b2772d322004a6bb04967f8437
+refs/heads/auto: 02c81fe2b5308bccbc90baae9e7ccdb8b915fe7d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/README.md

@@ -5,7 +5,7 @@ documentation.
 
 ## Quick Start
 
-1. Download a [binary insaller][installer] for your platform.
+1. Download a [binary installer][installer] for your platform.
 2. Read the [tutorial].
 3. Enjoy!
 

branches/auto/mk/crates.mk

@@ -49,14 +49,14 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := std green rustuv native flate arena glob term semver \
+TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
 		 workcache url log
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
-DEPS_std := native:rustrt native:compiler-rt native:backtrace
+DEPS_std := libc native:rustrt native:compiler-rt native:backtrace
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std

branches/auto/mk/dist.mk

@@ -215,7 +215,7 @@ dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 dist-install-dir-$(1): PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
 dist-install-dir-$(1): PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
 dist-install-dir-$(1): PREPARE_CLEAN=true
-dist-install-dir-$(1): prepare-base-dir-$(1)
+dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
 	$$(Q)(cd $$(PREPARE_DEST_DIR)/ && find . -type f | sed 's/^\.\///') \
       > tmp/dist/manifest-$(1).in
 	$$(Q)mv tmp/dist/manifest-$(1).in $$(PREPARE_DEST_DIR)/$$(CFG_LIBDIR_RELATIVE)/rustlib/manifest.in
@@ -224,6 +224,7 @@ dist-install-dir-$(1): prepare-base-dir-$(1)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-MIT $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)README.md $$(PREPARE_DEST_DIR)
+	$$(Q)cp -r doc $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_BIN_CMD) $$(S)src/etc/install.sh $$(PREPARE_DEST_DIR)
 
 dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)

branches/auto/mk/tests.mk

@@ -370,8 +370,6 @@ $(foreach host,$(CFG_HOST), \
 define DEF_TEST_CRATE_RULES
 check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4))
 
-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)): \
 		$(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2))
 	@$$(call E, run: $$<)
@@ -503,6 +501,10 @@ CTEST_BUILD_BASE_codegen = codegen
 CTEST_MODE_codegen = codegen
 CTEST_RUNTOOL_codegen = $(CTEST_RUNTOOL)
 
+# CTEST_DISABLE_$(TEST_GROUP), if set, will cause the test group to be
+# disabled and the associated message to be printed as a warning
+# during attempts to run those tests.
+
 ifeq ($(CFG_GDB),)
 CTEST_DISABLE_debuginfo = "no gdb found"
 endif
@@ -515,6 +517,14 @@ ifeq ($(CFG_OSTYPE),apple-darwin)
 CTEST_DISABLE_debuginfo = "gdb on darwing needs root"
 endif
 
+# CTEST_DISABLE_NONSELFHOST_$(TEST_GROUP), if set, will cause that
+# test group to be disabled *unless* the target is able to build a
+# compiler (i.e. when the target triple is in the set of of host
+# triples).  The associated message will be printed as a warning
+# during attempts to run those tests.
+
+CTEST_DISABLE_NONSELFHOST_rpass-full = "run-pass-full suite is unavailable when cross-compiling."
+
 define DEF_CTEST_VARS
 
 # All the per-stage build rules you might want to call from the
@@ -560,7 +570,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         $$(CTEST_TESTARGS)
 
 CTEST_DEPS_rpass_$(1)-T-$(2)-H-$(3) = $$(RPASS_TESTS)
-CTEST_DEPS_rpass_full_$(1)-T-$(2)-H-$(3) = $$(RPASS_FULL_TESTS) $$(TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3))
+CTEST_DEPS_rpass-full_$(1)-T-$(2)-H-$(3) = $$(RPASS_FULL_TESTS) $$(CSREQ$(1)_T_$(2)_H_$(3))
 CTEST_DEPS_rfail_$(1)-T-$(2)-H-$(3) = $$(RFAIL_TESTS)
 CTEST_DEPS_cfail_$(1)-T-$(2)-H-$(3) = $$(CFAIL_TESTS)
 CTEST_DEPS_bench_$(1)-T-$(2)-H-$(3) = $$(BENCH_TESTS)
@@ -587,8 +597,28 @@ CTEST_ARGS$(1)-T-$(2)-H-$(3)-$(4) := \
 
 check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4))
 
-ifeq ($$(CTEST_DISABLE_$(4)),)
+# CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4)
+# Goal: leave this variable as empty string if we should run the test.
+# Otherwise, set it to the reason we are not running the test.
+# (Encoded as a separate variable because GNU make does not have a
+# good way to express OR on ifeq commands)
 
+ifneq ($$(CTEST_DISABLE_$(4)),)
+# Test suite is disabled for all configured targets.
+CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4) := $$(CTEST_DISABLE_$(4))
+else
+# else, check if non-self-hosted target (i.e. target not-in hosts) ...
+ifeq ($$(findstring $(2),$$(CFG_HOST)),)
+# ... if so, then check if this test suite is disabled for non-selfhosts.
+ifneq ($$(CTEST_DISABLE_NONSELFHOST_$(4)),)
+# Test suite is disabled for this target.
+CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4) := $$(CTEST_DISABLE_NONSELFHOST_$(4))
+endif
+endif
+# Neither DISABLE nor DISABLE_NONSELFHOST is set ==> okay, run the test.
+endif
+
+ifeq ($$(CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4)),)
 $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 		$$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
                 $$(CTEST_DEPS_$(4)_$(1)-T-$(2)-H-$(3))
@@ -600,11 +630,9 @@ $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 
 else
 
-$$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
-		$$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
-                $$(CTEST_DEPS_$(4)_$(1)-T-$(2)-H-$(3))
+$$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)):
 	@$$(call E, run $(4) [$(2)]: $$<)
-	@$$(call E, warning: tests disabled: $$(CTEST_DISABLE_$(4)))
+	@$$(call E, warning: tests disabled: $$(CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4)))
 	touch $$@
 
 endif

branches/auto/src/compiletest/compiletest.rs

@@ -11,6 +11,9 @@
 #![crate_type = "bin"]
 #![feature(phase)]
 
+// we use our own (green) start below; do not link in libnative; issue #13247.
+#![no_start]
+
 #![allow(non_camel_case_types)]
 #![deny(warnings)]
 

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

@@ -12,7 +12,8 @@ The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:
 
 ~~~~ {.ignore}
-use std::libc::size_t;
+extern crate libc;
+use libc::size_t;
 
 #[link(name = "snappy")]
 extern {
@@ -44,7 +45,8 @@ keeping the binding correct at runtime.
 The `extern` block can be extended to cover the entire snappy API:
 
 ~~~~ {.ignore}
-use std::libc::{c_int, size_t};
+extern crate libc;
+use libc::{c_int, size_t};
 
 #[link(name = "snappy")]
 extern {
@@ -402,7 +404,7 @@ global state. In order to access these variables, you declare them in `extern`
 blocks with the `static` keyword:
 
 ~~~{.ignore}
-use std::libc;
+extern crate libc;
 
 #[link(name = "readline")]
 extern {
@@ -420,7 +422,7 @@ interface. To do this, statics can be declared with `mut` so rust can mutate
 them.
 
 ~~~{.ignore}
-use std::libc;
+extern crate libc;
 use std::ptr;
 
 #[link(name = "readline")]
@@ -444,11 +446,15 @@ calling foreign functions. Some foreign functions, most notably the Windows API,
 conventions. Rust provides a way to tell the compiler which convention to use:
 
 ~~~~
+extern crate libc;
+
 #[cfg(target_os = "win32", target_arch = "x86")]
 #[link(name = "kernel32")]
 extern "stdcall" {
-    fn SetEnvironmentVariableA(n: *u8, v: *u8) -> std::libc::c_int;
+    fn SetEnvironmentVariableA(n: *u8, v: *u8) -> libc::c_int;
 }
+
+# fn main() { }
 ~~~~
 
 This applies to the entire `extern` block. The list of supported ABI constraints

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

@@ -192,7 +192,8 @@ As an example, we give a reimplementation of owned boxes by wrapping
 reimplementation is as safe as the built-in `~` type.
 
 ```
-use std::libc::{c_void, size_t, malloc, free};
+extern crate libc;
+use libc::{c_void, size_t, malloc, free};
 use std::mem;
 use std::ptr;
 
@@ -294,7 +295,7 @@ asm!(assembly template
    );
 ```
 
-Any use of `asm` is feature gated (requires `#[feature(asm)];` on the
+Any use of `asm` is feature gated (requires `#![feature(asm)]` on the
 crate to allow) and of course requires an `unsafe` block.
 
 > **Note**: the examples here are given in x86/x86-64 assembly, but all
@@ -306,7 +307,7 @@ The `assembly template` is the only required parameter and must be a
 literal string (i.e `""`)
 
 ```
-#[feature(asm)];
+#![feature(asm)]
 
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "x86_64")]
@@ -334,7 +335,7 @@ Output operands, input operands, clobbers and options are all optional
 but you must add the right number of `:` if you skip them:
 
 ```
-# #[feature(asm)];
+# #![feature(asm)]
 # #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 asm!("xor %eax, %eax"
@@ -348,7 +349,7 @@ asm!("xor %eax, %eax"
 Whitespace also doesn't matter:
 
 ```
-# #[feature(asm)];
+# #![feature(asm)]
 # #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 asm!("xor %eax, %eax" ::: "eax");
@@ -362,7 +363,7 @@ Input and output operands follow the same format: `:
 expressions must be mutable lvalues:
 
 ```
-# #[feature(asm)];
+# #![feature(asm)]
 # #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 fn add(a: int, b: int) -> int {
     let mut c = 0;
@@ -390,7 +391,7 @@ compiler not to assume any values loaded into those registers will
 stay valid.
 
 ```
-# #[feature(asm)];
+# #![feature(asm)]
 # #[cfg(target_arch = "x86")] #[cfg(target_arch = "x86_64")]
 # fn main() { unsafe {
 // Put the value 0x200 in eax

branches/auto/src/doc/index.md

@@ -36,6 +36,7 @@ li {list-style-type: none; }
 * [The `glob` file path matching library](glob/index.html)
 * [The `green` M:N runtime library](green/index.html)
 * [The `hexfloat` library for hexadecimal floating-point literals](hexfloat/index.html)
+* [The `libc` bindings](libc/index.html)
 * [The `native` 1:1 threading runtime](native/index.html)
 * [The `num` arbitrary precision numerics library](num/index.html)
 * [The `rand` library for random numbers and distributions](rand/index.html)

branches/auto/src/doc/po/ja/rust.md.po

@@ -1,5 +1,5 @@
 # Japanese translations for Rust package
-# Copyright (C) 2013 The Rust Project Developers
+# Copyright (C) 2013-2014 The Rust Project Developers
 # This file is distributed under the same license as the Rust package.
 # Automatically generated, 2013.
 #
@@ -886,7 +886,7 @@ msgstr ""
 #: src/doc/rust.md:2008
 #, fuzzy
 #| msgid "~~~~ use std::task::spawn;"
-msgid "~~~~ {.ignore} #[warn(unstable)];"
+msgid "~~~~ {.ignore} #![warn(unstable)]"
 msgstr ""
 "~~~~\n"
 "use std::task::spawn;"

branches/auto/src/doc/rust.md

@@ -206,13 +206,12 @@ The keywords are the following strings:
 as
 break
 crate
-do
 else enum extern
 false fn for
 if impl in
 let loop
 match mod mut
-priv pub
+priv proc pub
 ref return
 self static struct super
 true trait type
@@ -1472,11 +1471,13 @@ with the exception that they may not have a body
 and are instead terminated by a semicolon.
 
 ~~~~
-# use std::libc::{c_char, FILE};
+extern crate libc;
+use libc::{c_char, FILE};
 
 extern {
     fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
 }
+# fn main() {}
 ~~~~
 
 Functions within external blocks may be called by Rust code,
@@ -2558,12 +2559,12 @@ task in a _failing state_.
 
 ~~~~ {.ignore}
 # use std::task;
-# do task::spawn {
+# task::spawn(proc() {
 
 ([1, 2, 3, 4])[0];
 (["a", "b"])[10]; // fails
 
-# }
+# })
 ~~~~
 
 ### Unary operator expressions
@@ -3421,8 +3422,21 @@ x = bo(5,7);
 
 ### Closure types
 
-The type of a closure mapping an input of type `A` to an output of type `B` is `|A| -> B`. A closure with no arguments or return values has type `||`.
+~~~~ {.notrust .ebnf .notation}
+closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
+                [ ':' bound-list ] [ '->' type ]
+procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
+                  [ ':' bound-list ] [ '->' type ]
+lifetime-list := lifetime | lifetime ',' lifetime-list
+arg-list := ident ':' type | ident ':' type ',' arg-list
+bound-list := bound | bound '+' bound-list
+bound := path | lifetime
+~~~~
 
+The type of a closure mapping an input of type `A` to an output of type `B` is
+`|A| -> B`. A closure with no arguments or return values has type `||`.
+Similarly, a procedure mapping `A` to `B` is `proc(A) -> B` and a no-argument
+and no-return value closure has type `proc()`.
 
 An example of creating and calling a closure:
 
@@ -3445,6 +3459,30 @@ call_closure(closure_no_args, closure_args);
 
 ```
 
+Unlike closures, procedures may only be invoked once, but own their
+environment, and are allowed to move out of their environment. Procedures are
+allocated on the heap (unlike closures). An example of creating and calling a
+procedure:
+
+```rust
+let string = ~"Hello";
+
+// Creates a new procedure, passing it to the `spawn` function.
+spawn(proc() {
+  println!("{} world!", string);
+});
+
+// the variable `string` has been moved into the previous procedure, so it is
+// no longer usable.
+
+
+// Create an invoke a procedure. Note that the procedure is *moved* when
+// invoked, so it cannot be invoked again.
+let f = proc(n: int) { n + 22 };
+println!("answer: {}", f(20));
+
+```
+
 ### Object types
 
 Every trait item (see [traits](#traits)) defines a type with the same name as the trait.