---

yaml
---
r: 129517
b: refs/heads/snap-stage3
c: 3e94401
h: refs/heads/master
i:
  129515: 444b5cc
v: v3

Author: tshepang

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 566b470e138e929e8a93d613372db1ba177c494f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 471862f40cbb30657640603a252f142122743498
+refs/heads/snap-stage3: 3e94401a6411001c7495a13dcbb289cb3935994f
 refs/heads/try: 80b45ddbd351f0a4a939c3a3c4e20b4defec4b35
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide.md

@@ -5531,9 +5531,9 @@ There are two circumstances where Rust's safety provisions don't work well.
 The first is when interfacing with C code, and the second is when building
 certain kinds of abstractions.
 
-Rust has support for FFI, (which you can read about in the [FFI
-Guide](guide-ffi.html)) but Rust can't guarantee that the C code will be safe,
-like Rust's will. Therefore, Rust marks such functions with the `unsafe`
+Rust has support for FFI (which you can read about in the [FFI
+Guide](guide-ffi.html)), but can't guarantee that the C code will be safe.
+Therefore, Rust marks such functions with the `unsafe`
 keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust

branches/snap-stage3/src/liballoc/heap.rs

@@ -208,7 +208,6 @@ mod imp {
 
 #[cfg(not(jemalloc), unix)]
 mod imp {
-    use core::cmp;
     use core::mem;
     use core::ptr;
     use libc;
@@ -249,7 +248,7 @@ mod imp {
     pub unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint,
                              old_size: uint) -> *mut u8 {
         let new_ptr = allocate(size, align);
-        ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
+        ptr::copy_memory(new_ptr, ptr as *const u8, old_size);
         deallocate(ptr, old_size, align);
         return new_ptr;
     }

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

@@ -1717,13 +1717,6 @@ pub trait StrSlice<'a> {
     fn utf16_units(&self) -> Utf16CodeUnits<'a>;
 }
 
-#[inline(never)]
-fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
-    assert!(begin <= end);
-    fail!("index {} and/or {} in `{}` do not lie on character boundary",
-          begin, end, s);
-}
-
 impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn contains<'a>(&self, needle: &'a str) -> bool {
@@ -1827,34 +1820,22 @@ impl<'a> StrSlice<'a> for &'a str {
 
     #[inline]
     fn slice(&self, begin: uint, end: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if begin <= end &&
-           self.is_char_boundary(begin) &&
-           self.is_char_boundary(end) {
-            unsafe { raw::slice_unchecked(*self, begin, end) }
-        } else {
-            slice_error_fail(*self, begin, end)
-        }
+        assert!(self.is_char_boundary(begin) && self.is_char_boundary(end),
+                "index {} and/or {} in `{}` do not lie on character boundary", begin,
+                end, *self);
+        unsafe { raw::slice_bytes(*self, begin, end) }
     }
 
     #[inline]
     fn slice_from(&self, begin: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if self.is_char_boundary(begin) {
-            unsafe { raw::slice_unchecked(*self, begin, self.len()) }
-        } else {
-            slice_error_fail(*self, begin, self.len())
-        }
+        self.slice(begin, self.len())
     }
 
     #[inline]
     fn slice_to(&self, end: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if self.is_char_boundary(end) {
-            unsafe { raw::slice_unchecked(*self, 0, end) }
-        } else {
-            slice_error_fail(*self, 0, end)
-        }
+        assert!(self.is_char_boundary(end), "index {} in `{}` does not lie on \
+                a character boundary", end, *self);
+        unsafe { raw::slice_bytes(*self, 0, end) }
     }
 
     fn slice_chars(&self, begin: uint, end: uint) -> &'a str {
@@ -1929,10 +1910,9 @@ impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn is_char_boundary(&self, index: uint) -> bool {
         if index == self.len() { return true; }
-        match self.as_bytes().get(index) {
-            None => false,
-            Some(&b) => b < 128u8 || b >= 192u8,
-        }
+        if index > self.len() { return false; }
+        let b = self.as_bytes()[index];
+        return b < 128u8 || b >= 192u8;
     }
 
     #[inline]

branches/snap-stage3/src/librustc/back/link.rs

@@ -536,13 +536,6 @@ pub mod write {
         llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
         llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
         llvm::LLVMPassManagerBuilderDispose(builder);
-
-        match opt {
-            llvm::CodeGenLevelDefault | llvm::CodeGenLevelAggressive => {
-                "mergefunc".with_c_str(|s| llvm::LLVMRustAddPass(mpm, s));
-            }
-            _ => {}
-        };
     }
 }
 

branches/snap-stage3/src/libstd/macros.rs

@@ -96,7 +96,7 @@ macro_rules! fail(
 macro_rules! assert(
     ($cond:expr) => (
         if !$cond {
-            fail!(concat!("assertion failed: ", stringify!($cond)))
+            fail!("assertion failed: {:s}", stringify!($cond))
         }
     );
     ($cond:expr, $($arg:expr),+) => (