---

yaml
---
r: 65111
b: refs/heads/master
c: f323b0c
h: refs/heads/master
i:
  65109: 904c71e
  65107: 8bc3aab
  65103: 1c5355f
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eef03c39cf2f25f2e2182a68d0fcad14f378d5ac
+refs/heads/master: f323b0c8bac704366eb307437faea231fb73b8d1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/tutorial.md

@@ -1977,7 +1977,7 @@ struct TimeBomb {
 
 impl Drop for TimeBomb {
     fn finalize(&self) {
-        for old_iter::repeat(self.explosivity) {
+        for self.explosivity.times {
             println("blam!");
         }
     }

trunk/src/compiletest/compiletest.rc

@@ -12,7 +12,7 @@
 
 #[allow(non_camel_case_types)];
 
-extern mod std(vers = "0.7-pre");
+extern mod std;
 
 use core::*;
 

trunk/src/driver/driver.rs

@@ -9,21 +9,21 @@
 // except according to those terms.
 
 #[cfg(rustpkg)]
-extern mod this(name = "rustpkg", vers = "0.7-pre");
+extern mod this(name = "rustpkg");
 
 #[cfg(fuzzer)]
-extern mod this(name = "fuzzer", vers = "0.7-pre");
+extern mod this(name = "fuzzer");
 
 #[cfg(rustdoc)]
-extern mod this(name = "rustdoc", vers = "0.7-pre");
+extern mod this(name = "rustdoc");
 
 #[cfg(rusti)]
-extern mod this(name = "rusti", vers = "0.7-pre");
+extern mod this(name = "rusti");
 
 #[cfg(rust)]
-extern mod this(name = "rust", vers = "0.7-pre");
+extern mod this(name = "rust");
 
 #[cfg(rustc)]
-extern mod this(name = "rustc", vers = "0.7-pre");
+extern mod this(name = "rustc");
 
 fn main() { this::main() }

trunk/src/libcore/at_vec.rs

@@ -294,30 +294,30 @@ mod test {
         }
 
         assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]);
-        assert!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]);
-        assert!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]);
+        assert_eq!(from_fn(5, |x| x+1), @[1, 2, 3, 4, 5]);
+        assert_eq!(from_elem(5, 3.14), @[3.14, 3.14, 3.14, 3.14, 3.14]);
     }
 
     #[test]
     fn append_test() {
-        assert!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]);
+        assert_eq!(@[1,2,3] + @[4,5,6], @[1,2,3,4,5,6]);
     }
 
     #[test]
     fn test_to_managed_consume() {
-        assert!(to_managed_consume::<int>(~[]) == @[]);
-        assert!(to_managed_consume(~[true]) == @[true]);
-        assert!(to_managed_consume(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(to_managed_consume(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
-        assert!(to_managed_consume(~[~[42]]) == @[~[42]]);
+        assert_eq!(to_managed_consume::<int>(~[]), @[]);
+        assert_eq!(to_managed_consume(~[true]), @[true]);
+        assert_eq!(to_managed_consume(~[1, 2, 3, 4, 5]), @[1, 2, 3, 4, 5]);
+        assert_eq!(to_managed_consume(~[~"abc", ~"123"]), @[~"abc", ~"123"]);
+        assert_eq!(to_managed_consume(~[~[42]]), @[~[42]]);
     }
 
     #[test]
     fn test_to_managed() {
-        assert!(to_managed::<int>([]) == @[]);
-        assert!(to_managed([true]) == @[true]);
-        assert!(to_managed([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(to_managed([@"abc", @"123"]) == @[@"abc", @"123"]);
-        assert!(to_managed([@[42]]) == @[@[42]]);
+        assert_eq!(to_managed::<int>([]), @[]);
+        assert_eq!(to_managed([true]), @[true]);
+        assert_eq!(to_managed([1, 2, 3, 4, 5]), @[1, 2, 3, 4, 5]);
+        assert_eq!(to_managed([@"abc", @"123"]), @[@"abc", @"123"]);
+        assert_eq!(to_managed([@[42]]), @[@[42]]);
     }
 }

trunk/src/libcore/bool.rs

@@ -113,14 +113,14 @@ mod tests {
 
     #[test]
     fn test_bool_to_str() {
-        assert!(to_str(false) == ~"false");
-        assert!(to_str(true) == ~"true");
+        assert_eq!(to_str(false), ~"false");
+        assert_eq!(to_str(true), ~"true");
     }
 
     #[test]
     fn test_bool_to_bit() {
         do all_values |v| {
-            assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
+            assert_eq!(to_bit(v), if is_true(v) { 1u8 } else { 0u8 });
         }
     }
 

trunk/src/libcore/cast.rs

@@ -24,20 +24,6 @@ pub mod rusti {
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(not(stage0))]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = unstable::intrinsics::uninit();
-    {
-        let dest_ptr: *mut u8 = rusti::transmute(&mut dest);
-        let src_ptr: *u8 = rusti::transmute(src);
-        unstable::intrinsics::memmove64(dest_ptr,
-                                        src_ptr,
-                                        sys::size_of::<U>() as u64);
-    }
-    dest
-}
-
-#[cfg(stage0)]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = unstable::intrinsics::init();
     {
@@ -145,7 +131,7 @@ mod tests {
 
     #[test]
     fn test_transmute_copy() {
-        assert!(1u == unsafe { ::cast::transmute_copy(&1) });
+        assert_eq!(1u, unsafe { ::cast::transmute_copy(&1) });
     }
 
     #[test]
@@ -177,7 +163,7 @@ mod tests {
     #[test]
     fn test_transmute2() {
         unsafe {
-            assert!(~[76u8, 0u8] == transmute(~"L"));
+            assert_eq!(~[76u8, 0u8], transmute(~"L"));
         }
     }
 }

trunk/src/libcore/cell.rs

@@ -122,7 +122,7 @@ fn test_with_ref() {
     let good = 6;
     let c = Cell(~[1, 2, 3, 4, 5, 6]);
     let l = do c.with_ref() |v| { v.len() };
-    assert!(l == good);
+    assert_eq!(l, good);
 }
 
 #[test]
@@ -132,5 +132,5 @@ fn test_with_mut_ref() {
     let c = Cell(v);
     do c.with_mut_ref() |v| { v.push(3); }
     let v = c.take();
-    assert!(v == good);
+    assert_eq!(v, good);
 }