---

yaml
---
r: 50471
b: refs/heads/auto
c: c4d2b79
h: refs/heads/master
i:
  50469: dc5de11
  50467: f428ace
  50463: a4af562
v: v3

Author: metajack

[refs]

@@ -14,5 +14,5 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 397a47852849ac2e286508f2315e695f5d8168cf
+refs/heads/auto: c4d2b7999a12b8c9111ae1d897c476c052ddc05a
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167

branches/auto/src/libcore/at_vec.rs

@@ -208,7 +208,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -226,7 +226,7 @@ pub mod raw {
 
     #[inline(always)] // really pretty please
     pub unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&v);
+        let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = addr_of(&((**repr).unboxed.data));

branches/auto/src/libcore/cell.rs

@@ -10,7 +10,7 @@
 
 //! A mutable, nullable memory location
 
-use cast::transmute_mut;
+use cast::transmute;
 use prelude::*;
 
 /*
@@ -20,12 +20,16 @@ Similar to a mutable option type, but friendlier.
 */
 
 pub struct Cell<T> {
-    value: Option<T>
+    mut value: Option<T>
 }
 
 impl<T:cmp::Eq> cmp::Eq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
-        (self.value) == (other.value)
+        unsafe {
+            let frozen_self: &Option<T> = transmute(&mut self.value);
+            let frozen_other: &Option<T> = transmute(&mut other.value);
+            frozen_self == frozen_other
+        }
     }
     fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) }
 }
@@ -42,7 +46,6 @@ pub fn empty_cell<T>() -> Cell<T> {
 pub impl<T> Cell<T> {
     /// Yields the value, failing if the cell is empty.
     fn take(&self) -> T {
-        let mut self = unsafe { transmute_mut(self) };
         if self.is_empty() {
             fail!(~"attempt to take an empty cell");
         }
@@ -54,7 +57,6 @@ pub impl<T> Cell<T> {
 
     /// Returns the value, failing if the cell is full.
     fn put_back(&self, value: T) {
-        let mut self = unsafe { transmute_mut(self) };
         if !self.is_empty() {
             fail!(~"attempt to put a value back into a full cell");
         }

branches/auto/src/libcore/str.rs

@@ -2274,8 +2274,8 @@ pub mod raw {
 
     /// Sets the length of the string and adds the null terminator
     pub unsafe fn set_len(v: &mut ~str, new_len: uint) {
-        let v: **mut vec::raw::VecRepr = cast::transmute(v);
-        let repr: *mut vec::raw::VecRepr = *v;
+        let v: **vec::raw::VecRepr = cast::transmute(v);
+        let repr: *vec::raw::VecRepr = *v;
         (*repr).unboxed.fill = new_len + 1u;
         let null = ptr::mut_offset(cast::transmute(&((*repr).unboxed.data)),
                                    new_len);

branches/auto/src/libcore/unstable.rs

@@ -106,21 +106,21 @@ fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
  ****************************************************************************/
 
 struct ArcData<T> {
-    count:     libc::intptr_t,
+    mut count:     libc::intptr_t,
     // FIXME(#3224) should be able to make this non-option to save memory
-    data:      Option<T>,
+    mut data:      Option<T>,
 }
 
 struct ArcDestruct<T> {
-    data: *libc::c_void,
+    mut data: *libc::c_void,
 }
 
 #[unsafe_destructor]
 impl<T> Drop for ArcDestruct<T>{
     fn finalize(&self) {
         unsafe {
             do task::unkillable {
-                let mut data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
+                let data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
                 let new_count =
                     intrinsics::atomic_xsub(&mut data.count, 1) - 1;
                 assert!(new_count >= 0);
@@ -185,7 +185,7 @@ pub unsafe fn get_shared_immutable_state<'a,T:Owned>(
 pub unsafe fn clone_shared_mutable_state<T:Owned>(rc: &SharedMutableState<T>)
         -> SharedMutableState<T> {
     unsafe {
-        let mut ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
+        let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         let new_count = intrinsics::atomic_xadd(&mut ptr.count, 1) + 1;
         assert!(new_count >= 2);
         cast::forget(ptr);
@@ -252,15 +252,15 @@ pub impl LittleLock {
     }
 }
 
-struct ExData<T> { lock: LittleLock, failed: bool, data: T, }
+struct ExData<T> { lock: LittleLock, mut failed: bool, mut data: T, }
 /**
  * An arc over mutable data that is protected by a lock. For library use only.
  */
 pub struct Exclusive<T> { x: SharedMutableState<ExData<T>> }
 
 pub fn exclusive<T:Owned>(user_data: T) -> Exclusive<T> {
     let data = ExData {
-        lock: LittleLock(), failed: false, data: user_data
+        lock: LittleLock(), mut failed: false, mut data: user_data
     };
     Exclusive { x: unsafe { shared_mutable_state(data) } }
 }

branches/auto/src/libcore/vec.rs

@@ -633,7 +633,7 @@ pub fn push<T>(v: &mut ~[T], initval: T) {
 // This doesn't bother to make sure we have space.
 #[inline(always)] // really pretty please
 unsafe fn push_fast<T>(v: &mut ~[T], initval: T) {
-    let repr: **mut raw::VecRepr = ::cast::transmute(v);
+    let repr: **raw::VecRepr = ::cast::transmute(v);
     let fill = (**repr).unboxed.fill;
     (**repr).unboxed.fill += sys::nonzero_size_of::<T>();
     let p = addr_of(&((**repr).unboxed.data));
@@ -2148,8 +2148,8 @@ pub unsafe fn from_buf<T>(ptr: *T, elts: uint) -> ~[T] {
 
 /// The internal 'unboxed' representation of a vector
 pub struct UnboxedVecRepr {
-    fill: uint,
-    alloc: uint,
+    mut fill: uint,
+    mut alloc: uint,
     data: u8
 }
 
@@ -2171,8 +2171,8 @@ pub mod raw {
     }
 
     pub struct SliceRepr {
-        data: *u8,
-        len: uint
+        mut data: *u8,
+        mut len: uint
     }
 
     /**
@@ -2184,7 +2184,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
-        let repr: **mut VecRepr = ::cast::transmute(v);
+        let repr: **VecRepr = ::cast::transmute(v);
         (**repr).unboxed.fill = new_len * sys::nonzero_size_of::<T>();
     }
 

branches/auto/src/libstd/net_url.rs

@@ -25,7 +25,7 @@ use core::to_str::ToStr;
 use core::to_str;
 use core::uint;
 
-#[deriving(Eq)]
+#[deriving(Clone, Eq)]
 struct Url {
     scheme: ~str,
     user: Option<UserInfo>,
@@ -36,7 +36,7 @@ struct Url {
     fragment: Option<~str>
 }
 
-#[deriving(Eq)]
+#[deriving(Clone, Eq)]
 struct UserInfo {
     user: ~str,
     pass: Option<~str>
@@ -398,7 +398,7 @@ pub fn get_scheme(rawurl: &str) -> Result<(~str, ~str), ~str> {
     return Err(~"url: Scheme must be terminated with a colon.");
 }
 
-#[deriving(Eq)]
+#[deriving(Clone, Eq)]
 enum Input {
     Digit, // all digits
     Hex, // digits and letters a-f