---

yaml
---
r: 135103
b: refs/heads/auto
c: 54831f1
h: refs/heads/master
i:
  135101: d25912e
  135099: 74ae5da
  135095: ea9811c
  135087: 2933d40
  135071: 8fd0343
  135039: fb277b7
v: v3

Author: tomjakubowski

[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: 655b7269c865b8ff446296bdb7640c6ad5c4f965
+refs/heads/auto: 54831f128fac3ad92bd7244aafaf52763452e51b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -488,7 +488,7 @@ esac
 
 # Continue supporting the old --enable-nightly flag to transition the bots
 # XXX Remove me
-if [ ! -z "$CFG_ENABLE_NIGHTLY" ]
+if [ $CFG_ENABLE_NIGHTLY -eq 1 ]
 then
     CFG_RELEASE_CHANNEL=nightly
     putvar CFG_RELEASE_CHANNEL

branches/auto/mk/crates.mk

@@ -59,7 +59,6 @@ CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_core :=
-DEPS_libc := core
 DEPS_rlibc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc

branches/auto/mk/stage0.mk

@@ -3,11 +3,8 @@
 $(HBIN0_H_$(CFG_BUILD))/:
 	mkdir -p $@
 
-# On windows these two are the same, so cause a redifinition warning
-ifneq ($(HBIN0_H_$(CFG_BUILD)),$(HLIB0_H_$(CFG_BUILD)))
 $(HLIB0_H_$(CFG_BUILD))/:
 	mkdir -p $@
-endif
 
 $(SNAPSHOT_RUSTC_POST_CLEANUP): \
 		$(S)src/snapshots.txt \

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

@@ -505,7 +505,6 @@ As being similar to this C code:
 {
     int *x;
     x = (int *)malloc(sizeof(int));
-    *x = 5;
 
     // stuff happens
 

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

@@ -72,8 +72,8 @@ is not used.
 Tests that should not be run can be annotated with the `ignore`
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
-by configuration using the `cfg_attr` attribute so, for example, to ignore a
-test on windows you can write `#[cfg_attr(windows, ignore)]`.
+by configuration so, for example, to ignore a test on windows you can
+write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
 `should_fail` attribute. The test will be run, and if it causes its

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

@@ -466,7 +466,7 @@ fn start(_argc: int, _argv: *const *const u8) -> int {
 // provided by libstd.
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
@@ -489,28 +489,32 @@ pub extern fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
 
 The compiler currently makes a few assumptions about symbols which are available
 in the executable to call. Normally these functions are provided by the standard
-library, but without it you must define your own.
+xlibrary, but without it you must define your own.
 
-The first of these three functions, `stack_exhausted`, is invoked whenever stack
+The first of these two functions, `stack_exhausted`, is invoked whenever stack
 overflow is detected.  This function has a number of restrictions about how it
 can be called and what it must do, but if the stack limit register is not being
 maintained then a task always has an "infinite stack" and this function
 shouldn't get triggered.
 
-The second of these three functions, `eh_personality`, is used by the
-failure mechanisms of the compiler. This is often mapped to GCC's
-personality function (see the
-[libstd implementation](std/rt/unwind/index.html) for more
-information), but crates which do not trigger failure can be assured
-that this function is never called. The final function, `fail_fmt`, is
-also used by the failure mechanisms of the compiler.
+The second of these two functions, `eh_personality`, is used by the failure
+mechanisms of the compiler. This is often mapped to GCC's personality function
+(see the [libstd implementation](std/rt/unwind/index.html) for more
+information), but crates which do not trigger failure can be assured that this
+function is never called.
+
+The final item in the example is a trait called `Sized`. This a trait
+that represents data of a known static size: it is integral to the
+Rust type system, and so the compiler expects the standard library to
+provide it. Since you are not using the standard library, you have to
+provide it yourself.
 
 ## Using libcore
 
@@ -569,8 +573,8 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
     return ret;
 }
 
-#[lang = "fail_fmt"]
-extern fn fail_fmt(args: &core::fmt::Arguments,
+#[lang = "begin_unwind"]
+extern fn begin_unwind(args: &core::fmt::Arguments,
                        file: &str,
                        line: uint) -> ! {
     loop {}
@@ -583,8 +587,8 @@ extern fn fail_fmt(args: &core::fmt::Arguments,
 ```
 
 Note that there is one extra lang item here which differs from the examples
-above, `fail_fmt`. This must be defined by consumers of libcore because the
-core library declares failure, but it does not define it. The `fail_fmt`
+above, `begin_unwind`. This must be defined by consumers of libcore because the
+core library declares failure, but it does not define it. The `begin_unwind`
 lang item is this crate's definition of failure, and it must be guaranteed to
 never return.
 
@@ -690,7 +694,7 @@ fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized {}
 ```
 
 Note the use of `abort`: the `exchange_malloc` lang item is assumed to
@@ -702,7 +706,7 @@ Other features provided by lang items include:
   `==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all
   marked with lang items; those specific four are `eq`, `ord`,
   `deref`, and `add` respectively.
-- stack unwinding and general failure; the `eh_personality`, `fail`
+- stack unwinding and general failure; the `eh_personality`, `fail_`
   and `fail_bounds_checks` lang items.
 - the traits in `std::kinds` used to indicate types that satisfy
   various kinds; lang items `send`, `sync` and `copy`.

branches/auto/src/doc/guide.md

@@ -1507,7 +1507,6 @@ You can create an array with just square brackets:
 
 ```{rust}
 let nums = [1i, 2i, 3i];
-let nums = [1i, ..20]; // Shorthand for an array of 20 elements all initialized to 1
 ```
 
 So what's the difference? An array has a fixed size, so you can't add or
@@ -4325,6 +4324,8 @@ and so we tell it that we want a vector of integers.
 is one:
 
 ```{rust}
+let one_to_one_hundred = range(0i, 100i);
+
 let greater_than_forty_two = range(0i, 100i)
                              .find(|x| *x >= 42);
 
@@ -4488,8 +4489,8 @@ This will print
 ```
 
 `filter()` is an adapter that takes a closure as an argument. This closure
-returns `true` or `false`. The new iterator `filter()` produces
-only the elements that that closure returns `true` for:
+returns `true` or `false`. The new iterator `filter()` produces returns
+only the elements that that closure returned `true` for:
 
 ```{rust}
 for i in range(1i, 100i).filter(|x| x % 2 == 0) {

branches/auto/src/etc/licenseck.py

@@ -46,7 +46,6 @@
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
     "test/bench/shootout-fasta.rs", # BSD
-    "test/bench/shootout-fasta-redux.rs", # BSD
     "test/bench/shootout-k-nucleotide.rs", # BSD
     "test/bench/shootout-mandelbrot.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD

branches/auto/src/liballoc/boxed.rs

@@ -96,6 +96,12 @@ pub trait BoxAny {
     /// `Err(Self)` if it isn't.
     #[unstable = "naming conventions around accessing innards may change"]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
+
+    /// Deprecated; this method has been renamed to `downcast`.
+    #[deprecated = "use downcast instead"]
+    fn move<T: 'static>(self) -> Result<Box<T>, Self> {
+        self.downcast::<T>()
+    }
 }
 
 #[stable]