---

yaml
---
r: 109982
b: refs/heads/master
c: b78ac5b
h: refs/heads/master
v: v3

Author: flaper87

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4af69f204e2365da0dc9f32bbd0eb3201dc9a9e0
+refs/heads/master: b78ac5b74a62e7b2772d322004a6bb04967f8437
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c7fac4471201977fdb1c0c0a26c87287e12dc644
 refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d

trunk/README.md

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

trunk/mk/crates.mk

@@ -49,14 +49,14 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
+TARGET_CRATES := 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 := libc native:rustrt native:compiler-rt native:backtrace
+DEPS_std := 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

trunk/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) docs compiler-docs
+dist-install-dir-$(1): prepare-base-dir-$(1)
 	$$(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,7 +224,6 @@ dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
 	$$(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)

trunk/mk/tests.mk

@@ -370,6 +370,8 @@ $(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: $$<)
@@ -501,10 +503,6 @@ 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
@@ -517,14 +515,6 @@ 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
@@ -570,7 +560,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) $$(CSREQ$(1)_T_$(2)_H_$(3))
+CTEST_DEPS_rpass_full_$(1)-T-$(2)-H-$(3) = $$(RPASS_FULL_TESTS) $$(TLIBRUSTC_DEFAULT$(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)
@@ -597,28 +587,8 @@ 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))
 
-# 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)
+ifeq ($$(CTEST_DISABLE_$(4)),)
 
-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))
@@ -630,9 +600,11 @@ $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 
 else
 
-$$(call TEST_OK_FILE,$(1),$(2),$(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))
 	@$$(call E, run $(4) [$(2)]: $$<)
-	@$$(call E, warning: tests disabled: $$(CTEST_DONT_RUN_$(1)-T-$(2)-H-$(3)-$(4)))
+	@$$(call E, warning: tests disabled: $$(CTEST_DISABLE_$(4)))
 	touch $$@
 
 endif

trunk/src/compiletest/compiletest.rs

@@ -11,9 +11,6 @@
 #![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)]
 

trunk/src/doc/guide-ffi.md

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

trunk/src/doc/guide-unsafe.md

@@ -192,8 +192,7 @@ As an example, we give a reimplementation of owned boxes by wrapping
 reimplementation is as safe as the built-in `~` type.
 
 ```
-extern crate libc;
-use libc::{c_void, size_t, malloc, free};
+use std::libc::{c_void, size_t, malloc, free};
 use std::mem;
 use std::ptr;
 
@@ -295,7 +294,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
@@ -307,7 +306,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")]
@@ -335,7 +334,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"
@@ -349,7 +348,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");
@@ -363,7 +362,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;
@@ -391,7 +390,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

trunk/src/doc/index.md

@@ -36,7 +36,6 @@ 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)

trunk/src/doc/po/ja/rust.md.po

@@ -1,5 +1,5 @@
 # Japanese translations for Rust package
-# Copyright (C) 2013-2014 The Rust Project Developers
+# Copyright (C) 2013 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;"

trunk/src/doc/rust.md

@@ -206,12 +206,13 @@ 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 proc pub
+priv pub
 ref return
 self static struct super
 true trait type
@@ -1471,13 +1472,11 @@ with the exception that they may not have a body
 and are instead terminated by a semicolon.
 
 ~~~~
-extern crate libc;
-use libc::{c_char, FILE};
+# use std::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,
@@ -2559,12 +2558,12 @@ task in a _failing state_.
 
 ~~~~ {.ignore}
 # use std::task;
-# task::spawn(proc() {
+# do task::spawn {
 
 ([1, 2, 3, 4])[0];
 (["a", "b"])[10]; // fails
 
-# })
+# }
 ~~~~
 
 ### Unary operator expressions
@@ -3422,21 +3421,8 @@ x = bo(5,7);
 
 ### Closure types
 
-~~~~ {.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 `||`.
 
-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:
 
@@ -3459,30 +3445,6 @@ 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.