---

yaml
---
r: 107963
b: refs/heads/dist-snap
c: 346d378
h: refs/heads/master
i:
  107961: e38e5ad
  107959: 1e0726c
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 882b4829ce340e6b1a54bdbc3322484ff8c9ffcd
+refs/heads/dist-snap: 346d378ad58ec32ad2eb500af1613a53b95bf143
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/crates.mk

@@ -49,7 +49,7 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := std extra green rustuv native flate arena glob term
+TARGET_CRATES := std extra green rustuv native flate arena glob term semver
 HOST_CRATES := syntax rustc rustdoc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -66,6 +66,7 @@ DEPS_flate := std native:miniz
 DEPS_arena := std extra
 DEPS_glob := std
 DEPS_term := std
+DEPS_semver := std
 
 TOOL_DEPS_compiletest := extra green rustuv
 TOOL_DEPS_rustdoc := rustdoc green rustuv

branches/dist-snap/src/doc/index.md

@@ -40,6 +40,7 @@ li {list-style-type: none; }
 * [The `arena` allocation library](arena/index.html)
 * [The `flate` compression library](flate/index.html)
 * [The `glob` file path matching library](glob/index.html)
+* [The `semver` version collation library](semver/index.html)
 * [The `term` terminal-handling library](term/index.html)
 
 # Tooling

branches/dist-snap/src/doc/rust.md

@@ -2426,9 +2426,9 @@ before the expression they apply to.
   : Logical negation. On the boolean type, this flips between `true` and
     `false`. On integer types, this inverts the individual bits in the
     two's complement representation of the value.
-`@` and `~`
+`~`
   :  [Boxing](#pointer-types) operators. Allocate a box to hold the value they are applied to,
-     and store the value in it. `@` creates a managed box, whereas `~` creates an owned box.
+     and store the value in it. `~` creates an owned box.
 `&`
   : Borrow operator. Returns a reference, pointing to its operand.
     The operand of a borrow is statically proven to outlive the resulting pointer.
@@ -3203,16 +3203,6 @@ All pointers in Rust are explicit first-class values.
 They can be copied, stored into data structures, and returned from functions.
 There are four varieties of pointer in Rust:
 
-Managed pointers (`@`)
-  : These point to managed heap allocations (or "boxes") in the task-local, managed heap.
-    Managed pointers are written `@content`,
-    for example `@int` means a managed pointer to a managed box containing an integer.
-    Copying a managed pointer is a "shallow" operation:
-    it involves only copying the pointer itself
-    (as well as any reference-count or GC-barriers required by the managed heap).
-    Dropping a managed pointer does not necessarily release the box it points to;
-    the lifecycles of managed boxes are subject to an unspecified garbage collection algorithm.
-
 Owning pointers (`~`)
   : These point to owned heap allocations (or "boxes") in the shared, inter-task heap.
     Each owned box has a single owning pointer; pointer and pointee retain a 1:1 relationship at all times.
@@ -3521,63 +3511,28 @@ state. Subsequent statements within a function may or may not initialize the
 local variables. Local variables can be used only after they have been
 initialized; this is enforced by the compiler.
 
-### Memory boxes
-
-A _box_ is a reference to a heap allocation holding another value. There
-are two kinds of boxes: *managed boxes* and *owned boxes*.
-
-A _managed box_ type or value is constructed by the prefix *at* sigil `@`.
-
-An _owned box_ type or value is constructed by the prefix *tilde* sigil `~`.
+### Owned boxes
 
-Multiple managed box values can point to the same heap allocation; copying a
-managed box value makes a shallow copy of the pointer (optionally incrementing
-a reference count, if the managed box is implemented through
-reference-counting).
+An  _owned box_ is a reference to a heap allocation holding another value, which is constructed
+by the prefix *tilde* sigil `~`
 
-Owned box values exist in 1:1 correspondence with their heap allocation.
-
-An example of constructing one managed box type and value, and one owned box
-type and value:
+An example of an owned box type and value:
 
 ~~~~
-let x: @int = @10;
 let x: ~int = ~10;
 ~~~~
 
-Some operations (such as field selection) implicitly dereference boxes. An
-example of an _implicit dereference_ operation performed on box values:
+Owned box values exist in 1:1 correspondence with their heap allocation
+copying an owned box value makes a shallow copy of the pointer
+Rust will consider a shallow copy of an owned box to move ownership of the value. After a value has been moved, the source location cannot be used unless it is reinitialized.
 
 ~~~~
-struct Foo { y: int }
-let x = @Foo{y: 10};
-assert!(x.y == 10);
-~~~~
-
-Other operations act on box values as single-word-sized address values. For
-these operations, to access the value held in the box requires an explicit
-dereference of the box value. Explicitly dereferencing a box is indicated with
-the unary *star* operator `*`. Examples of such _explicit dereference_
-operations are:
-
-* copying box values (`x = y`)
-* passing box values to functions (`f(x,y)`)
-
-An example of an explicit-dereference operation performed on box values:
-
+let x: ~int = ~10;
+let y = x;
+// attempting to use `x` will result in an error here
 ~~~~
-fn takes_boxed(b: @int) {
-}
 
-fn takes_unboxed(b: int) {
-}
 
-fn main() {
-    let x: @int = @10;
-    takes_boxed(x);
-    takes_unboxed(*x);
-}
-~~~~
 
 ## Tasks
 

branches/dist-snap/src/etc/licenseck.py

@@ -41,6 +41,7 @@
     "libstd/sync/mpsc_queue.rs", # BSD
     "libstd/sync/spsc_queue.rs", # BSD
     "libstd/sync/mpmc_bounded_queue.rs", # BSD
+    "libextra/sync/mpsc_intrusive.rs", # BSD
 ]
 
 def check_license(name, contents):

branches/dist-snap/src/libextra/lib.rs

@@ -83,7 +83,6 @@ pub mod rational;
 #[path="num/complex.rs"]
 pub mod complex;
 pub mod stats;
-pub mod semver;
 pub mod hex;
 pub mod uuid;
 

branches/dist-snap/src/libextra/sync.rs renamed to branches/dist-snap/src/libextra/sync/mod.rs

@@ -17,21 +17,24 @@
  * in std.
  */
 
-
+use std::cast;
 use std::comm;
-use std::unstable::sync::Exclusive;
+use std::kinds::marker;
 use std::sync::arc::UnsafeArc;
 use std::sync::atomics;
 use std::unstable::finally::Finally;
 use std::util;
-use std::util::NonCopyable;
 
 use arc::MutexArc;
 
 /****************************************************************************
  * Internals
  ****************************************************************************/
 
+pub mod mutex;
+pub mod one;
+mod mpsc_intrusive;
+
 // Each waiting task receives on one of these.
 #[doc(hidden)]
 type WaitEnd = Port<()>;
@@ -54,7 +57,7 @@ impl WaitQueue {
             comm::Data(ch) => {
                 // Send a wakeup signal. If the waiter was killed, its port will
                 // have closed. Keep trying until we get a live task.
-                if ch.try_send_deferred(()) {
+                if ch.try_send(()) {
                     true
                 } else {
                     self.signal()
@@ -69,7 +72,7 @@ impl WaitQueue {
         loop {
             match self.head.try_recv() {
                 comm::Data(ch) => {
-                    if ch.try_send_deferred(()) {
+                    if ch.try_send(()) {
                         count += 1;
                     }
                 }
@@ -81,36 +84,45 @@ impl WaitQueue {
 
     fn wait_end(&self) -> WaitEnd {
         let (wait_end, signal_end) = Chan::new();
-        assert!(self.tail.try_send_deferred(signal_end));
+        assert!(self.tail.try_send(signal_end));
         wait_end
     }
 }
 
 // The building-block used to make semaphores, mutexes, and rwlocks.
-#[doc(hidden)]
 struct SemInner<Q> {
+    lock: mutex::Mutex,
     count: int,
     waiters:   WaitQueue,
     // Can be either unit or another waitqueue. Some sems shouldn't come with
     // a condition variable attached, others should.
     blocked:   Q
 }
 
-#[doc(hidden)]
-struct Sem<Q>(Exclusive<SemInner<Q>>);
+struct Sem<Q>(UnsafeArc<SemInner<Q>>);
 
 #[doc(hidden)]
 impl<Q:Send> Sem<Q> {
     fn new(count: int, q: Q) -> Sem<Q> {
-        Sem(Exclusive::new(SemInner {
-            count: count, waiters: WaitQueue::new(), blocked: q }))
+        Sem(UnsafeArc::new(SemInner {
+            count: count,
+            waiters: WaitQueue::new(),
+            blocked: q,
+            lock: mutex::Mutex::new(),
+        }))
+    }
+
+    unsafe fn with(&self, f: |&mut SemInner<Q>|) {
+        let Sem(ref arc) = *self;
+        let state = arc.get();
+        let _g = (*state).lock.lock();
+        f(cast::transmute(state));
     }
 
     pub fn acquire(&self) {
         unsafe {
             let mut waiter_nobe = None;
-            let Sem(ref lock) = *self;
-            lock.with(|state| {
+            self.with(|state| {
                 state.count -= 1;
                 if state.count < 0 {
                     // Create waiter nobe, enqueue ourself, and tell
@@ -129,8 +141,7 @@ impl<Q:Send> Sem<Q> {
 
     pub fn release(&self) {
         unsafe {
-            let Sem(ref lock) = *self;
-            lock.with(|state| {
+            self.with(|state| {
                 state.count += 1;
                 if state.count <= 0 {
                     state.waiters.signal();
@@ -180,7 +191,7 @@ pub struct Condvar<'a> {
     // See the comment in write_cond for more detail.
     priv order: ReacquireOrderLock<'a>,
     // Make sure condvars are non-copyable.
-    priv token: util::NonCopyable,
+    priv nopod: marker::NoPod,
 }
 
 impl<'a> Condvar<'a> {
@@ -210,8 +221,7 @@ impl<'a> Condvar<'a> {
         let mut out_of_bounds = None;
         // Release lock, 'atomically' enqueuing ourselves in so doing.
         unsafe {
-            let Sem(ref queue) = *self.sem;
-            queue.with(|state| {
+            self.sem.with(|state| {
                 if condvar_id < state.blocked.len() {
                     // Drop the lock.
                     state.count += 1;
@@ -253,8 +263,7 @@ impl<'a> Condvar<'a> {
         unsafe {
             let mut out_of_bounds = None;
             let mut result = false;
-            let Sem(ref lock) = *self.sem;
-            lock.with(|state| {
+            self.sem.with(|state| {
                 if condvar_id < state.blocked.len() {
                     result = state.blocked[condvar_id].signal();
                 } else {
@@ -276,8 +285,7 @@ impl<'a> Condvar<'a> {
         let mut out_of_bounds = None;
         let mut queue = None;
         unsafe {
-            let Sem(ref lock) = *self.sem;
-            lock.with(|state| {
+            self.sem.with(|state| {
                 if condvar_id < state.blocked.len() {
                     // To avoid :broadcast_heavy, we make a new waitqueue,
                     // swap it out with the old one, and broadcast on the
@@ -326,7 +334,7 @@ impl Sem<~[WaitQueue]> {
             blk(&Condvar {
                 sem: self,
                 order: Nothing,
-                token: NonCopyable
+                nopod: marker::NoPod
             })
         })
     }
@@ -566,7 +574,7 @@ impl RWLock {
             (&self.order_lock).release();
             let opt_lock = Just(&self.order_lock);
             blk(&Condvar { sem: cond.sem, order: opt_lock,
-                           token: NonCopyable })
+                           nopod: marker::NoPod })
         })
     }
 
@@ -601,7 +609,7 @@ impl RWLock {
         (&self.access_lock).acquire();
         (&self.order_lock).release();
         (|| {
-            blk(RWLockWriteMode { lock: self, token: NonCopyable })
+            blk(RWLockWriteMode { lock: self, nopod: marker::NoPod })
         }).finally(|| {
             let writer_or_last_reader;
             // Check if we're releasing from read mode or from write mode.
@@ -654,16 +662,16 @@ impl RWLock {
                 (&self.access_lock).release();
             }
         }
-        RWLockReadMode { lock: token.lock, token: NonCopyable }
+        RWLockReadMode { lock: token.lock, nopod: marker::NoPod }
     }
 }
 
 /// The "write permission" token used for rwlock.write_downgrade().
 
-pub struct RWLockWriteMode<'a> { priv lock: &'a RWLock, priv token: NonCopyable }
+pub struct RWLockWriteMode<'a> { priv lock: &'a RWLock, priv nopod: marker::NoPod }
 /// The "read permission" token used for rwlock.write_downgrade().
 pub struct RWLockReadMode<'a> { priv lock: &'a RWLock,
-                                   priv token: NonCopyable }
+                                   priv nopod: marker::NoPod }
 
 impl<'a> RWLockWriteMode<'a> {
     /// Access the pre-downgrade rwlock in write mode.
@@ -674,7 +682,7 @@ impl<'a> RWLockWriteMode<'a> {
         // access lock. See comment in RWLock::write_cond for why.
         blk(&Condvar { sem:        &self.lock.access_lock,
                        order: Just(&self.lock.order_lock),
-                       token: NonCopyable })
+                       nopod: marker::NoPod })
     }
 }