---

yaml
---
r: 129525
b: refs/heads/snap-stage3
c: 46cf384
h: refs/heads/master
i:
  129523: 12d6d96
v: v3

Author: Sawyer47

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 566b470e138e929e8a93d613372db1ba177c494f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 17f79af31c4d413352a967b6cfe9ba7d70f66ff7
+refs/heads/snap-stage3: 46cf384ba9a598fe3b29d5b2fbb3b83e681ff77d
 refs/heads/try: 80b45ddbd351f0a4a939c3a3c4e20b4defec4b35
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -2021,7 +2021,7 @@ And trying it out:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 57
 Please input your guess.
@@ -2292,7 +2292,7 @@ print an error message and return. Let's give this a shot:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 17
 Please input your guess.
@@ -2358,11 +2358,11 @@ Let's try it!
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 58
 Please input your guess.
-  76
+  76  
 You guessed: 76
 Too big!
 $
@@ -2436,7 +2436,7 @@ that `return`? If we give a non-number answer, we'll `return` and quit. Observe:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 59
 Please input your guess.
@@ -2569,7 +2569,7 @@ Now we should be good! Let's try:
 ```{rust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 61
 Please input your guess.
@@ -3718,18 +3718,18 @@ That's a lot to take in. It's also one of the _most_ important concepts in
 all of Rust. Let's see this syntax in action:
 
 ```{rust}
-{
+{ 
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // other code here...
-
+   
 } // privilege 1: when x goes out of scope, this memory is deallocated
 
 /// this function borrows an integer. It's given back automatically when the
 /// function returns.
-fn foo(x: &int) -> &int { x }
+fn foo(x: &int) -> &int { x } 
 
-{
+{ 
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // privilege 2: you may lend that resource, to as many borrowers as you'd like
@@ -3739,14 +3739,14 @@ fn foo(x: &int) -> &int { x }
     foo(&x); // functions can borrow too!
 
     let a = &x; // we can do this alllllll day!
-}
+} 
 
-{
+{ 
     let mut x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     let y = &mut x; // privilege 3: you may lend that resource to a single borrower,
                     // mutably
-}
+}   
 ```
 
 If you are a borrower, you get a few privileges as well, but must also obey a
@@ -4535,7 +4535,7 @@ let one_to_one_hundred = range(0i, 100i).collect();
 ```
 
 As you can see, we call `collect()` on our iterator. `collect()` takes
-as many values as the iterator will give it, and returns a collection
+as many values as the iterator will give it, and returns a collection 
 of the results. So why won't this compile? Rust can't determine what
 type of things you want to collect, and so you need to let it know.
 Here's the version that does compile:
@@ -5508,7 +5508,7 @@ fn main() {
 }
 ```
 
-Whew! This isn't too terrible. You can see that we still `let x = 5i`,
+Whew! This isn't too terrible. You can see that we still `let x = 5i`, 
 but then things get a little bit hairy. Three more bindings get set: a
 static format string, an argument vector, and the aruments. We then
 invoke the `println_args` function with the generated arguments.
@@ -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 can't guarantee that the C code will be safe.
-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 Rust can't guarantee that the C code will be safe,
+like Rust's will. 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/iter.rs

@@ -728,10 +728,6 @@ pub trait ExactSize<A> : DoubleEndedIterator<A> {
     /// Return the exact length of the iterator.
     fn len(&self) -> uint {
         let (lower, upper) = self.size_hint();
-        // Note: This assertion is overly defensive, but it checks the invariant
-        // guaranteed by the trait. If this trait were rust-internal,
-        // we could use debug_assert!; assert_eq! will check all Rust user
-        // implementations too.
         assert_eq!(upper, Some(lower));
         lower
     }
@@ -1199,20 +1195,21 @@ impl<A, B, T: ExactSize<A>, U: ExactSize<B>> DoubleEndedIterator<(A, B)>
 for Zip<T, U> {
     #[inline]
     fn next_back(&mut self) -> Option<(A, B)> {
-        let a_sz = self.a.len();
-        let b_sz = self.b.len();
-        if a_sz != b_sz {
-            // Adjust a, b to equal length
-            if a_sz > b_sz {
-                for _ in range(0, a_sz - b_sz) { self.a.next_back(); }
-            } else {
-                for _ in range(0, b_sz - a_sz) { self.b.next_back(); }
-            }
-        }
+        let (a_sz, a_upper) = self.a.size_hint();
+        let (b_sz, b_upper) = self.b.size_hint();
+        assert!(a_upper == Some(a_sz));
+        assert!(b_upper == Some(b_sz));
+        if a_sz < b_sz {
+            for _ in range(0, b_sz - a_sz) { self.b.next_back(); }
+        } else if a_sz > b_sz {
+            for _ in range(0, a_sz - b_sz) { self.a.next_back(); }
+        }
+        let (a_sz, _) = self.a.size_hint();
+        let (b_sz, _) = self.b.size_hint();
+        assert!(a_sz == b_sz);
         match (self.a.next_back(), self.b.next_back()) {
             (Some(x), Some(y)) => Some((x, y)),
-            (None, None) => None,
-            _ => unreachable!(),
+            _ => None
         }
     }
 }
@@ -1398,8 +1395,9 @@ impl<A, T: ExactSize<A>> DoubleEndedIterator<(uint, A)> for Enumerate<T> {
     fn next_back(&mut self) -> Option<(uint, A)> {
         match self.iter.next_back() {
             Some(a) => {
-                let len = self.iter.len();
-                Some((self.count + len, a))
+                let (lower, upper) = self.iter.size_hint();
+                assert!(upper == Some(lower));
+                Some((self.count + lower, a))
             }
             _ => None
         }

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

@@ -1507,8 +1507,8 @@ pub trait StrSlice<'a> {
     ///
     /// # Example
     ///
-    /// This example manually iterates through the characters of a
-    /// string; this should normally be done by `.chars()` or
+    /// This example manually iterate through the characters of a
+    /// string; this should normally by done by `.chars()` or
     /// `.char_indices`.
     ///
     /// ```rust

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/librustc/middle/const_eval.rs

@@ -517,26 +517,29 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
                 match ty::get(ety).sty {
                     ty::ty_float(_) => {
                         match val {
+                            const_bool(b) => Ok(const_float(b as f64)),
                             const_uint(u) => Ok(const_float(u as f64)),
                             const_int(i) => Ok(const_float(i as f64)),
                             const_float(f) => Ok(const_float(f)),
-                            _ => Err("can't cast float to str".to_string()),
+                            _ => Err("can't cast this type to float".to_string()),
                         }
                     }
                     ty::ty_uint(_) => {
                         match val {
+                            const_bool(b) => Ok(const_uint(b as u64)),
                             const_uint(u) => Ok(const_uint(u)),
                             const_int(i) => Ok(const_uint(i as u64)),
                             const_float(f) => Ok(const_uint(f as u64)),
-                            _ => Err("can't cast str to uint".to_string()),
+                            _ => Err("can't cast this type to uint".to_string()),
                         }
                     }
-                    ty::ty_int(_) | ty::ty_bool => {
+                    ty::ty_int(_) => {
                         match val {
+                            const_bool(b) => Ok(const_int(b as i64)),
                             const_uint(u) => Ok(const_int(u as i64)),
                             const_int(i) => Ok(const_int(i)),
                             const_float(f) => Ok(const_int(f as i64)),
-                            _ => Err("can't cast str to int".to_string()),
+                            _ => Err("can't cast this type to int".to_string()),
                         }
                     }
                     _ => Err("can't cast this type".to_string())

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),+) => (

branches/snap-stage3/src/test/run-pass/cast-in-array-size.rs

@@ -16,4 +16,5 @@ fn main() {
     let _a: [bool, ..1 as uint];
     let _b: [int, ..SIZE as uint] = [1, ..SIZE as uint];
     let _c: [bool, ..'\n' as uint] = [true, ..'\n' as uint];
+    let _d: [bool, ..true as uint] = [true, ..true as uint];
 }