---

yaml
---
r: 155435
b: refs/heads/try2
c: e520bb1
h: refs/heads/master
i:
  155433: 2facaf2
  155431: 9a2e9f9
v: v3

Author: sfackler

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d64b4103d688f38c2e9e2daf966d50beeb383f1e
+refs/heads/try2: e520bb1b2f1667f17c3503af71273921c4fc9989
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/mk/rt.mk

@@ -203,9 +203,6 @@ LIBUV_CFLAGS_$(1) := $(subst -Werror,,$(CFG_GCCISH_CFLAGS_$(1)))
 
 $$(LIBUV_MAKEFILE_$(1)): $$(LIBUV_DEPS) $$(MKFILE_DEPS) $$(LIBUV_STAMP_$(1))
 	(cd $(S)src/libuv/ && \
-	CC="$$(CC_$(1))" \
-	CXX="$$(CXX_$(1))" \
-	AR="$$(AR_$(1))" \
 	 $$(CFG_PYTHON) ./gyp_uv.py -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
 	   -D ninja \
 	   -DOS=$$(LIBUV_OSTYPE_$(1)) \
@@ -228,9 +225,6 @@ else ifeq ($(OSTYPE_$(1)), apple-ios) # iOS
 $$(LIBUV_XCODEPROJ_$(1)): $$(LIBUV_DEPS) $$(MKFILE_DEPS) $$(LIBUV_STAMP_$(1))
 	cp -rf $(S)src/libuv/ $$(LIBUV_BUILD_DIR_$(1))
 	(cd $$(LIBUV_BUILD_DIR_$(1)) && \
-	CC="$$(CC_$(1))" \
-	CXX="$$(CXX_$(1))" \
-	AR="$$(AR_$(1))" \
 	 $$(CFG_PYTHON) ./gyp_uv.py -f xcode \
 	   -D ninja \
 	   -R libuv)

branches/try2/mk/tests.mk

@@ -60,14 +60,11 @@ ifdef VERBOSE
   CTEST_TESTARGS += --verbose
 endif
 
-# Setting locale ensures that gdb's output remains consistent.
-# This prevents tests from failing with some locales (fixes #17423).
-export LC_ALL=C
-
 # If we're running perf then set this environment variable
 # to put the benchmarks into 'hard mode'
 ifeq ($(MAKECMDGOALS),perf)
-  export RUST_BENCH=1
+  RUST_BENCH=1
+  export RUST_BENCH
 endif
 
 TEST_LOG_FILE=tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).log

branches/try2/src/compiletest/runtest.rs

@@ -444,8 +444,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                      "-nx".to_string(),
                      format!("-command={}", debugger_script.as_str().unwrap()));
 
-            let mut gdb_path = tool_path;
-            gdb_path.push_str("/bin/arm-linux-androideabi-gdb");
+            let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
             let procsrv::Result {
                 out,
                 err,

branches/try2/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/try2/src/etc/vim/compiler/cargo.vim

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

branches/try2/src/libcollections/dlist.rs

@@ -850,16 +850,6 @@ 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];
@@ -870,39 +860,22 @@ 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: &mut [int] = &mut [11, 12, 13];
-        assert!(a.tailn(0) == b);
+        let b: &[int] = &[11, 12, 13];
+        assert_eq!(a.tailn(0), b);
         a = vec![11i, 12, 13];
-        let b: &mut [int] = &mut [13];
-        assert!(a.tailn(2) == b);
+        let b: &[int] = &[13];
+        assert_eq!(a.tailn(2), b);
     }
 
     #[test]
@@ -923,30 +896,13 @@ 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() {
@@ -976,16 +932,6 @@ 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.
@@ -1131,7 +1077,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_grow_set() {
         let mut v = vec![1i, 2, 3];
         v.grow_set(4u, &4, 5);
@@ -1665,7 +1610,6 @@ mod tests {
 
     #[test]
     #[should_fail]
-    #[allow(deprecated)]
     fn test_copy_memory_oob() {
         unsafe {
             let mut a = [1i, 2, 3, 4];
@@ -1849,26 +1793,6 @@ 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/try2/src/libcollections/slice.rs

@@ -698,7 +698,7 @@ pub trait StrAllocating: Str {
         let me = self.as_slice();
         let mut out = String::with_capacity(me.len());
         for c in me.chars() {
-            c.escape_default(|c| out.push(c));
+            c.escape_default(|c| out.push_char(c));
         }
         out
     }
@@ -708,7 +708,7 @@ pub trait StrAllocating: Str {
         let me = self.as_slice();
         let mut out = String::with_capacity(me.len());
         for c in me.chars() {
-            c.escape_unicode(|c| out.push(c));
+            c.escape_unicode(|c| out.push_char(c));
         }
         out
     }