---

yaml
---
r: 135003
b: refs/heads/snap-stage3
c: e04e081
h: refs/heads/master
i:
  135001: e80ab4b
  134999: f642aec
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 7eb9337dace88c5ded431aa7507f06d50619131b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 88a8def0a373348e18cf4ce98f256da063618be1
+refs/heads/snap-stage3: e04e081fa7f0cd31911a6a2cc1c98aed066a7647
 refs/heads/try: 14378ea357c06c23607ca61ade44f60a7a64a1c7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/crates.mk

@@ -59,6 +59,7 @@ 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/snap-stage3/src/doc/guide-pointers.md

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

branches/snap-stage3/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 so, for example, to ignore a test on windows you can
-write `#[ignore(cfg(target_os = "win32"))]`.
+by configuration using the `cfg_attr` attribute so, for example, to ignore a
+test on windows you can write `#[cfg_attr(windows, ignore)]`.
 
 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/snap-stage3/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 = "sized"] trait Sized { }
+#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
 # // fn main() {} tricked you, rustdoc!
 ```
 
@@ -489,7 +489,7 @@ 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 = "sized"] trait Sized { }
+#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
 # // fn main() {} tricked you, rustdoc!
 ```
 
@@ -498,23 +498,19 @@ 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.
 
-The first of these two functions, `stack_exhausted`, is invoked whenever stack
+The first of these three 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 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.
+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.
 
 ## Using libcore
 
@@ -573,8 +569,8 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
     return ret;
 }
 
-#[lang = "begin_unwind"]
-extern fn begin_unwind(args: &core::fmt::Arguments,
+#[lang = "fail_fmt"]
+extern fn fail_fmt(args: &core::fmt::Arguments,
                        file: &str,
                        line: uint) -> ! {
     loop {}
@@ -587,8 +583,8 @@ extern fn begin_unwind(args: &core::fmt::Arguments,
 ```
 
 Note that there is one extra lang item here which differs from the examples
-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`
+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`
 lang item is this crate's definition of failure, and it must be guaranteed to
 never return.
 
@@ -694,7 +690,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 = "sized"] trait Sized {}
+#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
 ```
 
 Note the use of `abort`: the `exchange_malloc` lang item is assumed to
@@ -706,7 +702,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/snap-stage3/src/libcollections/dlist.rs

@@ -844,6 +844,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_append() {
         {
             let mut m = DList::new();

branches/snap-stage3/src/libcollections/slice.rs

@@ -850,6 +850,16 @@ mod tests {
         assert_eq!(a.as_slice().head().unwrap(), &11);
     }
 
+    #[test]
+    fn test_head_mut() {
+        let mut a = vec![];
+        assert_eq!(a.as_mut_slice().head_mut(), None);
+        a = vec![11i];
+        assert_eq!(*a.as_mut_slice().head_mut().unwrap(), 11);
+        a = vec![11i, 12];
+        assert_eq!(*a.as_mut_slice().head_mut().unwrap(), 11);
+    }
+
     #[test]
     fn test_tail() {
         let mut a = vec![11i];
@@ -860,22 +870,39 @@ mod tests {
         assert_eq!(a.tail(), b);
     }
 
+    #[test]
+    fn test_tail_mut() {
+        let mut a = vec![11i];
+        let b: &mut [int] = &mut [];
+        assert!(a.as_mut_slice().tail_mut() == b);
+        a = vec![11i, 12];
+        let b: &mut [int] = &mut [12];
+        assert!(a.as_mut_slice().tail_mut() == b);
+    }
+
     #[test]
     #[should_fail]
     fn test_tail_empty() {
         let a: Vec<int> = vec![];
         a.tail();
     }
 
+    #[test]
+    #[should_fail]
+    fn test_tail_mut_empty() {
+        let mut a: Vec<int> = vec![];
+        a.as_mut_slice().tail_mut();
+    }
+
     #[test]
     #[allow(deprecated)]
     fn test_tailn() {
         let mut a = vec![11i, 12, 13];
-        let b: &[int] = &[11, 12, 13];
-        assert_eq!(a.tailn(0), b);
+        let b: &mut [int] = &mut [11, 12, 13];
+        assert!(a.tailn(0) == b);
         a = vec![11i, 12, 13];
-        let b: &[int] = &[13];
-        assert_eq!(a.tailn(2), b);
+        let b: &mut [int] = &mut [13];
+        assert!(a.tailn(2) == b);
     }
 
     #[test]
@@ -896,13 +923,30 @@ mod tests {
         assert_eq!(a.init(), b);
     }
 
+    #[test]
+    fn test_init_mut() {
+        let mut a = vec![11i];
+        let b: &mut [int] = &mut [];
+        assert!(a.as_mut_slice().init_mut() == b);
+        a = vec![11i, 12];
+        let b: &mut [int] = &mut [11];
+        assert!(a.as_mut_slice().init_mut() == b);
+    }
+
     #[test]
     #[should_fail]
     fn test_init_empty() {
         let a: Vec<int> = vec![];
         a.init();
     }
 
+    #[test]
+    #[should_fail]
+    fn test_init_mut_empty() {
+        let mut a: Vec<int> = vec![];
+        a.as_mut_slice().init_mut();
+    }
+
     #[test]
     #[allow(deprecated)]
     fn test_initn() {
@@ -932,6 +976,16 @@ mod tests {
         assert_eq!(a.as_slice().last().unwrap(), &12);
     }
 
+    #[test]
+    fn test_last_mut() {
+        let mut a = vec![];
+        assert_eq!(a.as_mut_slice().last_mut(), None);
+        a = vec![11i];
+        assert_eq!(*a.as_mut_slice().last_mut().unwrap(), 11);
+        a = vec![11i, 12];
+        assert_eq!(*a.as_mut_slice().last_mut().unwrap(), 12);
+    }
+
     #[test]
     fn test_slice() {
         // Test fixed length vector.
@@ -1077,6 +1131,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_grow_set() {
         let mut v = vec![1i, 2, 3];
         v.grow_set(4u, &4, 5);
@@ -1610,6 +1665,7 @@ mod tests {
 
     #[test]
     #[should_fail]
+    #[allow(deprecated)]
     fn test_copy_memory_oob() {
         unsafe {
             let mut a = [1i, 2, 3, 4];
@@ -1793,6 +1849,26 @@ mod tests {
         assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>().as_slice(), splits);
     }
 
+    #[test]
+    fn test_splitnator_mut() {
+        let xs = &mut [1i,2,3,4,5];
+
+        let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]];
+        assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>().as_slice(),
+                   splits);
+        let splits: &[&mut [int]] = &[&mut [1], &mut [3,4,5]];
+        assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>().as_slice(),
+                   splits);
+        let splits: &[&mut [int]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
+        assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<&mut [int]>>().as_slice(),
+                   splits);
+
+        let xs: &mut [int] = &mut [];
+        let splits: &[&mut [int]] = &[&mut []];
+        assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<&mut [int]>>().as_slice(),
+                   splits);
+    }
+
     #[test]
     fn test_rsplitator() {
         let xs = &[1i,2,3,4,5];

branches/snap-stage3/src/libcore/cmp.rs

@@ -39,7 +39,7 @@
 
 #![stable]
 
-use option::{Option, Some};
+use option::{Option, Some, None};
 
 /// Trait for values that can be compared for equality and inequality.
 ///
@@ -268,6 +268,32 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
     if v1 > v2 { v1 } else { v2 }
 }
 
+/// Compare and return the minimum of two values if there is one.
+///
+/// Returns the first argument if the comparison determines them to be equal.
+#[inline]
+#[experimental]
+pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
+    match v1.partial_cmp(&v2) {
+        Some(Less) | Some(Equal) => Some(v1),
+        Some(Greater) => Some(v2),
+        None => None
+    }
+}
+
+/// Compare and return the maximum of two values if there is one.
+///
+/// Returns the first argument if the comparison determines them to be equal.
+#[inline]
+#[experimental]
+pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
+    match v1.partial_cmp(&v2) {
+        Some(Less) => Some(v2),
+        Some(Equal) | Some(Greater) => Some(v1),
+        None => None
+    }
+}
+
 // Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types
 mod impls {
     use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering,