---

yaml
---
r: 107962
b: refs/heads/dist-snap
c: 882b482
h: refs/heads/master
v: v3

Author: alexcrichton

[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: c1395ea58866ede7f52864ab36b8052f88d20bc4
+refs/heads/dist-snap: 882b4829ce340e6b1a54bdbc3322484ff8c9ffcd
 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 semver
+TARGET_CRATES := std extra green rustuv native flate arena glob term
 HOST_CRATES := syntax rustc rustdoc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -66,7 +66,6 @@ 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,7 +40,6 @@ 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 an owned box.
+     and store the value in it. `@` creates a managed box, whereas `~` 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,6 +3203,16 @@ 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.
@@ -3511,28 +3521,63 @@ 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.
 
-### Owned boxes
+### 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 `~`.
 
-An  _owned box_ is a reference to a heap allocation holding another value, which is constructed
-by the prefix *tilde* sigil `~`
+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 example of an owned box type and value:
+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:
 
 ~~~~
+let x: @int = @10;
 let x: ~int = ~10;
 ~~~~
 
-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.
+Some operations (such as field selection) implicitly dereference boxes. An
+example of an _implicit dereference_ operation performed on box values:
 
 ~~~~
-let x: ~int = ~10;
-let y = x;
-// attempting to use `x` will result in an error here
+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:
+
 ~~~~
+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,7 +41,6 @@
     "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,6 +83,7 @@ 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/libsemver/lib.rs renamed to branches/dist-snap/src/libextra/semver.rs

@@ -28,11 +28,6 @@
 //! An example version number with all five components is
 //! `0.8.1-rc.3.0+20130922.linux`.
 
-#[crate_id = "semver#0.10-pre"];
-#[crate_type = "rlib"];
-#[crate_type = "dylib"];
-#[license = "MIT/ASL2"];
-
 use std::char;
 use std::cmp;
 use std::option::{Option, Some, None};

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

@@ -17,24 +17,21 @@
  * in std.
  */
 
-use std::cast;
+
 use std::comm;
-use std::kinds::marker;
+use std::unstable::sync::Exclusive;
 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<()>;
@@ -57,7 +54,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(()) {
+                if ch.try_send_deferred(()) {
                     true
                 } else {
                     self.signal()
@@ -72,7 +69,7 @@ impl WaitQueue {
         loop {
             match self.head.try_recv() {
                 comm::Data(ch) => {
-                    if ch.try_send(()) {
+                    if ch.try_send_deferred(()) {
                         count += 1;
                     }
                 }
@@ -84,45 +81,36 @@ impl WaitQueue {
 
     fn wait_end(&self) -> WaitEnd {
         let (wait_end, signal_end) = Chan::new();
-        assert!(self.tail.try_send(signal_end));
+        assert!(self.tail.try_send_deferred(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
 }
 
-struct Sem<Q>(UnsafeArc<SemInner<Q>>);
+#[doc(hidden)]
+struct Sem<Q>(Exclusive<SemInner<Q>>);
 
 #[doc(hidden)]
 impl<Q:Send> Sem<Q> {
     fn new(count: int, q: Q) -> Sem<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));
+        Sem(Exclusive::new(SemInner {
+            count: count, waiters: WaitQueue::new(), blocked: q }))
     }
 
     pub fn acquire(&self) {
         unsafe {
             let mut waiter_nobe = None;
-            self.with(|state| {
+            let Sem(ref lock) = *self;
+            lock.with(|state| {
                 state.count -= 1;
                 if state.count < 0 {
                     // Create waiter nobe, enqueue ourself, and tell
@@ -141,7 +129,8 @@ impl<Q:Send> Sem<Q> {
 
     pub fn release(&self) {
         unsafe {
-            self.with(|state| {
+            let Sem(ref lock) = *self;
+            lock.with(|state| {
                 state.count += 1;
                 if state.count <= 0 {
                     state.waiters.signal();
@@ -191,7 +180,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 nopod: marker::NoPod,
+    priv token: util::NonCopyable,
 }
 
 impl<'a> Condvar<'a> {
@@ -221,7 +210,8 @@ impl<'a> Condvar<'a> {
         let mut out_of_bounds = None;
         // Release lock, 'atomically' enqueuing ourselves in so doing.
         unsafe {
-            self.sem.with(|state| {
+            let Sem(ref queue) = *self.sem;
+            queue.with(|state| {
                 if condvar_id < state.blocked.len() {
                     // Drop the lock.
                     state.count += 1;
@@ -263,7 +253,8 @@ impl<'a> Condvar<'a> {
         unsafe {
             let mut out_of_bounds = None;
             let mut result = false;
-            self.sem.with(|state| {
+            let Sem(ref lock) = *self.sem;
+            lock.with(|state| {
                 if condvar_id < state.blocked.len() {
                     result = state.blocked[condvar_id].signal();
                 } else {
@@ -285,7 +276,8 @@ impl<'a> Condvar<'a> {
         let mut out_of_bounds = None;
         let mut queue = None;
         unsafe {
-            self.sem.with(|state| {
+            let Sem(ref lock) = *self.sem;
+            lock.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
@@ -334,7 +326,7 @@ impl Sem<~[WaitQueue]> {
             blk(&Condvar {
                 sem: self,
                 order: Nothing,
-                nopod: marker::NoPod
+                token: NonCopyable
             })
         })
     }
@@ -574,7 +566,7 @@ impl RWLock {
             (&self.order_lock).release();
             let opt_lock = Just(&self.order_lock);
             blk(&Condvar { sem: cond.sem, order: opt_lock,
-                           nopod: marker::NoPod })
+                           token: NonCopyable })
         })
     }
 
@@ -609,7 +601,7 @@ impl RWLock {
         (&self.access_lock).acquire();
         (&self.order_lock).release();
         (|| {
-            blk(RWLockWriteMode { lock: self, nopod: marker::NoPod })
+            blk(RWLockWriteMode { lock: self, token: NonCopyable })
         }).finally(|| {
             let writer_or_last_reader;
             // Check if we're releasing from read mode or from write mode.
@@ -662,16 +654,16 @@ impl RWLock {
                 (&self.access_lock).release();
             }
         }
-        RWLockReadMode { lock: token.lock, nopod: marker::NoPod }
+        RWLockReadMode { lock: token.lock, token: NonCopyable }
     }
 }
 
 /// The "write permission" token used for rwlock.write_downgrade().
 
-pub struct RWLockWriteMode<'a> { priv lock: &'a RWLock, priv nopod: marker::NoPod }
+pub struct RWLockWriteMode<'a> { priv lock: &'a RWLock, priv token: NonCopyable }
 /// The "read permission" token used for rwlock.write_downgrade().
 pub struct RWLockReadMode<'a> { priv lock: &'a RWLock,
-                                   priv nopod: marker::NoPod }
+                                   priv token: NonCopyable }
 
 impl<'a> RWLockWriteMode<'a> {
     /// Access the pre-downgrade rwlock in write mode.
@@ -682,7 +674,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),
-                       nopod: marker::NoPod })
+                       token: NonCopyable })
     }
 }