---

yaml
---
r: 77273
b: refs/heads/snap-stage3
c: c2bc59e
h: refs/heads/master
i:
  77271: da7be3c
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: f1132496dddbdd88f321a7919eec3d65136b3f75
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3ab0561b00d2993706d11bfbbce4a357110195dd
+refs/heads/snap-stage3: c2bc59e0869889d9b996da99915f95ae89ddff00
 refs/heads/try: ebfe63cd1c0b5d23f7ea60c69b4fde2e30cfd42a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/arc.rs

@@ -44,7 +44,7 @@ use sync;
 use sync::{Mutex, RWLock};
 
 use std::cast;
-use std::unstable::sync::UnsafeArc;
+use std::unstable::sync::UnsafeAtomicRcBox;
 use std::task;
 use std::borrow;
 
@@ -108,7 +108,7 @@ impl<'self> Condvar<'self> {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-pub struct Arc<T> { priv x: UnsafeArc<T> }
+pub struct Arc<T> { priv x: UnsafeAtomicRcBox<T> }
 
 
 /**
@@ -118,7 +118,7 @@ pub struct Arc<T> { priv x: UnsafeArc<T> }
 impl<T:Freeze+Send> Arc<T> {
     /// Create an atomically reference counted wrapper.
     pub fn new(data: T) -> Arc<T> {
-        Arc { x: UnsafeArc::new(data) }
+        Arc { x: UnsafeAtomicRcBox::new(data) }
     }
 
     pub fn get<'a>(&'a self) -> &'a T {
@@ -160,7 +160,7 @@ impl<T:Freeze + Send> Clone for Arc<T> {
 #[doc(hidden)]
 struct MutexArcInner<T> { priv lock: Mutex, priv failed: bool, priv data: T }
 /// An Arc with mutable data protected by a blocking mutex.
-struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
+struct MutexArc<T> { priv x: UnsafeAtomicRcBox<MutexArcInner<T>> }
 
 
 impl<T:Send> Clone for MutexArc<T> {
@@ -187,7 +187,7 @@ impl<T:Send> MutexArc<T> {
             lock: Mutex::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        MutexArc { x: UnsafeArc::new(data) }
+        MutexArc { x: UnsafeAtomicRcBox::new(data) }
     }
 
     /**
@@ -309,7 +309,7 @@ struct RWArcInner<T> { priv lock: RWLock, priv failed: bool, priv data: T }
  */
 #[no_freeze]
 struct RWArc<T> {
-    priv x: UnsafeArc<RWArcInner<T>>,
+    priv x: UnsafeAtomicRcBox<RWArcInner<T>>,
 }
 
 impl<T:Freeze + Send> Clone for RWArc<T> {
@@ -335,7 +335,7 @@ impl<T:Freeze + Send> RWArc<T> {
             lock: RWLock::new_with_condvars(num_condvars),
             failed: false, data: user_data
         };
-        RWArc { x: UnsafeArc::new(data), }
+        RWArc { x: UnsafeAtomicRcBox::new(data), }
     }
 
     /**

branches/snap-stage3/src/libextra/sync.rs

@@ -21,7 +21,7 @@ use std::comm;
 use std::comm::SendDeferred;
 use std::comm::{GenericPort, Peekable};
 use std::task;
-use std::unstable::sync::{Exclusive, UnsafeArc};
+use std::unstable::sync::{Exclusive, UnsafeAtomicRcBox};
 use std::unstable::atomics;
 use std::unstable::finally::Finally;
 use std::util;
@@ -135,7 +135,9 @@ impl<Q:Send> Sem<Q> {
         do task::unkillable {
             do (|| {
                 self.acquire();
-                do task::rekillable { blk() }
+                unsafe {
+                    do task::rekillable { blk() }
+                }
             }).finally {
                 self.release();
             }
@@ -232,8 +234,10 @@ impl<'self> Condvar<'self> {
                 // signaller already sent -- I mean 'unconditionally' in contrast
                 // with acquire().)
                 do (|| {
-                    do task::rekillable {
-                        let _ = WaitEnd.take_unwrap().recv();
+                    unsafe {
+                        do task::rekillable {
+                            let _ = WaitEnd.take_unwrap().recv();
+                        }
                     }
                 }).finally {
                     // Reacquire the condvar. Note this is back in the unkillable
@@ -444,7 +448,7 @@ struct RWLockInner {
 pub struct RWLock {
     priv order_lock:  Semaphore,
     priv access_lock: Sem<~[WaitQueue]>,
-    priv state:       UnsafeArc<RWLockInner>,
+    priv state:       UnsafeAtomicRcBox<RWLockInner>,
 }
 
 impl RWLock {
@@ -456,7 +460,7 @@ impl RWLock {
     * Similar to mutex_with_condvars.
     */
     pub fn new_with_condvars(num_condvars: uint) -> RWLock {
-        let state = UnsafeArc::new(RWLockInner {
+        let state = UnsafeAtomicRcBox::new(RWLockInner {
             read_mode:  false,
             read_count: atomics::AtomicUint::new(0),
         });
@@ -512,12 +516,14 @@ impl RWLock {
      * 'write' from other tasks will run concurrently with this one.
      */
     pub fn write<U>(&self, blk: &fn() -> U) -> U {
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    blk()
+        unsafe {
+            do task::unkillable {
+                (&self.order_lock).acquire();
+                do (&self.access_lock).access {
+                    (&self.order_lock).release();
+                    do task::rekillable {
+                        blk()
+                    }
                 }
             }
         }
@@ -556,14 +562,16 @@ impl RWLock {
         // which can't happen until T2 finishes the downgrade-read entirely.
         // The astute reader will also note that making waking writers use the
         // order_lock is better for not starving readers.
-        do task::unkillable {
-            (&self.order_lock).acquire();
-            do (&self.access_lock).access_cond |cond| {
-                (&self.order_lock).release();
-                do task::rekillable {
-                    let opt_lock = Just(&self.order_lock);
-                    blk(&Condvar { sem: cond.sem, order: opt_lock,
-                                   token: NonCopyable::new() })
+        unsafe {
+            do task::unkillable {
+                (&self.order_lock).acquire();
+                do (&self.access_lock).access_cond |cond| {
+                    (&self.order_lock).release();
+                    do task::rekillable {
+                        let opt_lock = Just(&self.order_lock);
+                        blk(&Condvar { sem: cond.sem, order: opt_lock,
+                                       token: NonCopyable::new() })
+                    }
                 }
             }
         }
@@ -598,8 +606,10 @@ impl RWLock {
             (&self.access_lock).acquire();
             (&self.order_lock).release();
             do (|| {
-                do task::rekillable {
-                    blk(RWLockWriteMode { lock: self, token: NonCopyable::new() })
+                unsafe {
+                    do task::rekillable {
+                        blk(RWLockWriteMode { lock: self, token: NonCopyable::new() })
+                    }
                 }
             }).finally {
                 let writer_or_last_reader;

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -3476,18 +3476,18 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
         terr_ptr_mutability => ~"pointers differ in mutability",
         terr_ref_mutability => ~"references differ in mutability",
         terr_ty_param_size(values) => {
-            fmt!("expected a type with %? type params \
-                  but found one with %? type params",
+            fmt!("expected a type with %u type params \
+                  but found one with %u type params",
                  values.expected, values.found)
         }
         terr_tuple_size(values) => {
-            fmt!("expected a tuple with %? elements \
-                  but found one with %? elements",
+            fmt!("expected a tuple with %u elements \
+                  but found one with %u elements",
                  values.expected, values.found)
         }
         terr_record_size(values) => {
-            fmt!("expected a record with %? fields \
-                  but found one with %? fields",
+            fmt!("expected a record with %u fields \
+                  but found one with %u fields",
                  values.expected, values.found)
         }
         terr_record_mutability => {

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

@@ -43,6 +43,7 @@ let unwrapped_msg = match msg {
 
 use clone::Clone;
 use cmp::{Eq,Ord};
+use ops::Add;
 use util;
 use num::Zero;
 use iterator;
@@ -76,6 +77,18 @@ impl<T: Eq + Ord> Ord for Option<T> {
     }
 }
 
+impl<T: Add<T, T>> Add<Option<T>, Option<T>> for Option<T> {
+    #[inline]
+    fn add(&self, other: &Option<T>) -> Option<T> {
+        match (&*self, &*other) {
+            (&None, &None) => None,
+            (_, &None) => None,
+            (&None, _) => None,
+            (&Some(ref lhs), &Some(ref rhs)) => Some(*lhs + *rhs)
+        }
+    }
+}
+
 // FIXME: #8242 implementing manually because deriving doesn't work for some reason
 impl<T: ToStr> ToStr for Option<T> {
     fn to_str(&self) -> ~str {

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

@@ -75,35 +75,50 @@ impl Repr for bool {
     }
 }
 
-macro_rules! int_repr(($ty:ident) => (impl Repr for $ty {
+impl Repr for int {
+    fn write_repr(&self, writer: @Writer) {
+        do ::int::to_str_bytes(*self, 10u) |bits| {
+            writer.write(bits);
+        }
+    }
+}
+
+macro_rules! int_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty {
     fn write_repr(&self, writer: @Writer) {
         do ::$ty::to_str_bytes(*self, 10u) |bits| {
             writer.write(bits);
+            writer.write(bytes!($suffix));
         }
     }
 }))
 
-int_repr!(int)
-int_repr!(i8)
-int_repr!(i16)
-int_repr!(i32)
-int_repr!(i64)
-int_repr!(uint)
-int_repr!(u8)
-int_repr!(u16)
-int_repr!(u32)
-int_repr!(u64)
-
-macro_rules! num_repr(($ty:ident) => (impl Repr for $ty {
+int_repr!(i8, "i8")
+int_repr!(i16, "i16")
+int_repr!(i32, "i32")
+int_repr!(i64, "i64")
+int_repr!(uint, "u")
+int_repr!(u8, "u8")
+int_repr!(u16, "u16")
+int_repr!(u32, "u32")
+int_repr!(u64, "u64")
+
+impl Repr for float {
+    fn write_repr(&self, writer: @Writer) {
+        let s = self.to_str();
+        writer.write(s.as_bytes());
+    }
+}
+
+macro_rules! num_repr(($ty:ident, $suffix:expr) => (impl Repr for $ty {
     fn write_repr(&self, writer: @Writer) {
         let s = self.to_str();
         writer.write(s.as_bytes());
+        writer.write(bytes!($suffix));
     }
 }))
 
-num_repr!(float)
-num_repr!(f32)
-num_repr!(f64)
+num_repr!(f32, "f32")
+num_repr!(f64, "f64")
 
 // New implementation using reflect::MovePtr
 
@@ -602,7 +617,7 @@ fn test_repr() {
     exact_test(&(@[1,2,3,4,5,6,7,8]),
                "@[1, 2, 3, 4, 5, 6, 7, 8]");
     exact_test(&(@[1u8,2u8,3u8,4u8]),
-               "@[1, 2, 3, 4]");
+               "@[1u8, 2u8, 3u8, 4u8]");
     exact_test(&(@["hi", "there"]),
                "@[\"hi\", \"there\"]");
     exact_test(&(~["hi", "there"]),
@@ -615,14 +630,14 @@ fn test_repr() {
                "@{a: 10, b: 1.234}");
     exact_test(&(~P{a:10, b:1.234}),
                "~{a: 10, b: 1.234}");
-    exact_test(&(10_u8, ~"hello"),
-               "(10, ~\"hello\")");
-    exact_test(&(10_u16, ~"hello"),
-               "(10, ~\"hello\")");
-    exact_test(&(10_u32, ~"hello"),
-               "(10, ~\"hello\")");
-    exact_test(&(10_u64, ~"hello"),
-               "(10, ~\"hello\")");
+    exact_test(&(10u8, ~"hello"),
+               "(10u8, ~\"hello\")");
+    exact_test(&(10u16, ~"hello"),
+               "(10u16, ~\"hello\")");
+    exact_test(&(10u32, ~"hello"),
+               "(10u32, ~\"hello\")");
+    exact_test(&(10u64, ~"hello"),
+               "(10u64, ~\"hello\")");
 
     struct Foo;
     exact_test(&(~[Foo, Foo, Foo]), "~[{}, {}, {}]");

branches/snap-stage3/src/libstd/rt/comm.rs

@@ -21,7 +21,7 @@ use rt::local::Local;
 use rt::select::{SelectInner, SelectPortInner};
 use select::{Select, SelectPort};
 use unstable::atomics::{AtomicUint, AtomicOption, Acquire, Relaxed, SeqCst};
-use unstable::sync::UnsafeArc;
+use unstable::sync::UnsafeAtomicRcBox;
 use util::Void;
 use comm::{GenericChan, GenericSmartChan, GenericPort, Peekable};
 use cell::Cell;
@@ -567,14 +567,14 @@ impl<'self, T> SelectPort<T> for &'self Port<T> { }
 
 pub struct SharedChan<T> {
     // Just like Chan, but a shared AtomicOption instead of Cell
-    priv next: UnsafeArc<AtomicOption<StreamChanOne<T>>>
+    priv next: UnsafeAtomicRcBox<AtomicOption<StreamChanOne<T>>>
 }
 
 impl<T> SharedChan<T> {
     pub fn new(chan: Chan<T>) -> SharedChan<T> {
         let next = chan.next.take();
         let next = AtomicOption::new(~next);
-        SharedChan { next: UnsafeArc::new(next) }
+        SharedChan { next: UnsafeAtomicRcBox::new(next) }
     }
 }
 
@@ -620,7 +620,7 @@ impl<T> Clone for SharedChan<T> {
 
 pub struct SharedPort<T> {
     // The next port on which we will receive the next port on which we will receive T
-    priv next_link: UnsafeArc<AtomicOption<PortOne<StreamPortOne<T>>>>
+    priv next_link: UnsafeAtomicRcBox<AtomicOption<PortOne<StreamPortOne<T>>>>
 }
 
 impl<T> SharedPort<T> {
@@ -630,7 +630,7 @@ impl<T> SharedPort<T> {
         let (next_link_port, next_link_chan) = oneshot();
         next_link_chan.send(next_data_port);
         let next_link = AtomicOption::new(~next_link_port);
-        SharedPort { next_link: UnsafeArc::new(next_link) }
+        SharedPort { next_link: UnsafeAtomicRcBox::new(next_link) }
     }
 }