---

yaml
---
r: 110198
b: refs/heads/auto
c: d0e60b7
h: refs/heads/master
v: v3

Author: sfackler

[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: 31e8f2448c8cdd913566d5cb9a5cb9f0c014dcbc
+refs/heads/auto: d0e60b72ee3f5fb07b01143d82362cb42307f32d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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

branches/auto/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

branches/auto/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)]
 

branches/auto/src/compiletest/procsrv.rs

@@ -84,8 +84,8 @@ pub fn run(lib_path: &str,
 
             Some(Result {
                 status: status,
-                out: str::from_utf8_owned(output).unwrap(),
-                err: str::from_utf8_owned(error).unwrap()
+                out: str::from_utf8(output.as_slice()).unwrap().to_owned(),
+                err: str::from_utf8(error.as_slice()).unwrap().to_owned()
             })
         },
         Err(..) => None

branches/auto/src/compiletest/runtest.rs

@@ -153,7 +153,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
         match props.pp_exact { Some(_) => 1, None => 2 };
 
     let src = File::open(testfile).read_to_end().unwrap();
-    let src = str::from_utf8_owned(src).unwrap();
+    let src = str::from_utf8(src.as_slice()).unwrap().to_owned();
     let mut srcs = vec!(src);
 
     let mut round = 0;
@@ -177,7 +177,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
         Some(ref file) => {
             let filepath = testfile.dir_path().join(file);
             let s = File::open(&filepath).read_to_end().unwrap();
-            str::from_utf8_owned(s).unwrap()
+            str::from_utf8(s.as_slice()).unwrap().to_owned()
           }
           None => { (*srcs.get(srcs.len() - 2u)).clone() }
         };
@@ -1163,7 +1163,7 @@ fn disassemble_extract(config: &config, _props: &TestProps,
 
 fn count_extracted_lines(p: &Path) -> uint {
     let x = File::open(&p.with_extension("ll")).read_to_end().unwrap();
-    let x = str::from_utf8_owned(x).unwrap();
+    let x = str::from_utf8(x.as_slice()).unwrap();
     x.lines().len()
 }
 

branches/auto/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

branches/auto/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;
 

branches/auto/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)
@@ -67,10 +66,6 @@ li {list-style-type: none; }
 
 # External resources
 
-* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/)
-    * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - general discussion
-    * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) - game development
-    * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) - compiler and libraries
-    * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) - operating system development
+* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org
 * The Rust community on [Reddit](http://reddit.com/r/rust)
 * The Rust [wiki](http://github.com/mozilla/rust/wiki)

branches/auto/src/doc/rust.md

@@ -1471,13 +1471,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,
@@ -3422,21 +3420,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 +3444,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.

branches/auto/src/etc/zsh/_rust

@@ -36,12 +36,11 @@ _rustc_opts_switches=(
     --target'[Target triple cpu-manufacturer-kernel\[-os\] to compile]'
     --target-cpu'[Select target processor (llc -mcpu=help for details)]'
     --target-feature'[Target specific attributes (llc -mattr=help for details)]'
-    --relocation-model'[Relocation model (llc --help for details)]'
     {-v,--version}'[Print version info and exit]'
 )
 _rustc_opts_lint=(
     'attribute-usage[detects bad use of attributes]'
-    'ctypes[proper use of libc types in foreign modules]'
+    'ctypes[proper use of std::libc types in foreign modules]'
     'dead-assignment[detect assignments that will never be read]'
     'dead-code[detect piece of code that will never be used]'
     'default-type-param-usage[prevents explicitly setting a type parameter with a default]'

branches/auto/src/libcollections/hashmap.rs

@@ -30,12 +30,11 @@ use std::result::{Ok, Err};
 use std::slice::ImmutableVector;
 
 mod table {
-    extern crate libc;
-
     use std::clone::Clone;
     use std::cmp::Eq;
     use std::hash::{Hash, Hasher};
     use std::kinds::marker;
+    use std::libc;
     use std::num::CheckedMul;
     use std::option::{Option, Some, None};
     use std::prelude::Drop;

branches/auto/src/libflate/lib.rs

@@ -26,14 +26,13 @@ Simple compression
 
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 
-extern crate libc;
-
+use std::libc::{c_void, size_t, c_int};
+use std::libc;
 use std::c_vec::CVec;
-use libc::{c_void, size_t, c_int};
-
 
 pub mod rustrt {
-    use libc::{c_void, size_t, c_int};
+    use std::libc::{c_int, c_void, size_t};
+
     #[link(name = "miniz", kind = "static")]
     extern {
         pub fn tdefl_compress_mem_to_heap(psrc_buf: *c_void,

branches/auto/src/libgreen/lib.rs

@@ -199,7 +199,6 @@
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 #[cfg(test)] extern crate rustuv;
 extern crate rand;
-extern crate libc;
 
 use std::mem::replace;
 use std::os;

branches/auto/src/libgreen/macros.rs

@@ -52,7 +52,7 @@ macro_rules! rtabort (
 
 pub fn dumb_println(args: &fmt::Arguments) {
     use std::io;
-    use libc;
+    use std::libc;
 
     struct Stderr;
     impl io::Writer for Stderr {

branches/auto/src/libgreen/sched.rs

@@ -976,7 +976,7 @@ fn new_sched_rng() -> XorShiftRng {
 }
 #[cfg(unix)]
 fn new_sched_rng() -> XorShiftRng {
-    use libc;
+    use std::libc;
     use std::mem;
     use rand::SeedableRng;
 

branches/auto/src/libgreen/stack.rs

@@ -11,7 +11,7 @@
 use std::rt::env::max_cached_stacks;
 use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
               MapNonStandardFlags, MapVirtual};
-use libc;
+use std::libc;
 
 /// A task's stack. The name "Stack" is a vestige of segmented stacks.
 pub struct Stack {