---

yaml
---
r: 107983
b: refs/heads/dist-snap
c: 8d8c783
h: refs/heads/master
i:
  107981: 58b5f92
  107979: 9ec3abf
  107975: 88986bc
  107967: 07755de
v: v3

Author: nrc

[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: 4509b49451cbd2e078fa81c6adb218ff33d6d779
+refs/heads/dist-snap: 8d8c7835f76ff835f1bb71481bf564c2785a32e8
 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 uuid
+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
@@ -67,7 +67,6 @@ DEPS_arena := std extra
 DEPS_glob := std
 DEPS_term := std
 DEPS_semver := std
-DEPS_uuid := std extra
 
 TOOL_DEPS_compiletest := extra green rustuv
 TOOL_DEPS_rustdoc := rustdoc green rustuv

branches/dist-snap/mk/tests.mk

@@ -183,8 +183,8 @@ check-test: cleantestlibs cleantmptestlogs all check-stage2-rfail
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 check-lite: cleantestlibs cleantmptestlogs \
-	$(foreach crate,$(TARGET_CRATES),check-stage2-$(crate)) \
-	check-stage2-rpass \
+	check-stage2-std check-stage2-extra check-stage2-rpass \
+	check-stage2-rustuv check-stage2-native check-stage2-green \
 	check-stage2-rfail check-stage2-cfail check-stage2-rmake
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
@@ -861,8 +861,7 @@ $(foreach host,$(CFG_HOST), \
  $(eval $(foreach target,$(CFG_TARGET), \
    $(eval $(call DEF_CHECK_FAST_FOR_T_H,,$(target),$(host))))))
 
-check-fast: tidy check-fast-H-$(CFG_BUILD) \
-	    $(foreach crate,$(TARGET_CRATES),check-stage2-$(crate))
+check-fast: tidy check-fast-H-$(CFG_BUILD) check-stage2-std check-stage2-extra
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 define DEF_CHECK_FAST_FOR_H

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

@@ -42,7 +42,6 @@ li {list-style-type: none; }
 * [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)
-* [The UUID library](uuid/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/libextra/arc.rs

@@ -554,50 +554,6 @@ impl<'a, T:Freeze + Send> RWReadMode<'a, T> {
     }
 }
 
-/****************************************************************************
- * Copy-on-write Arc
- ****************************************************************************/
-
-pub struct CowArc<T> { priv x: UnsafeArc<T> }
-
-/// A Copy-on-write Arc functions the same way as an `arc` except it allows
-/// mutation of the contents if there is only a single reference to
-/// the data. If there are multiple references the data is automatically
-/// cloned and the task modifies the cloned data in place of the shared data.
-impl<T:Clone+Send+Freeze> CowArc<T> {
-    /// Create a copy-on-write atomically reference counted wrapper
-    #[inline]
-    pub fn new(data: T) -> CowArc<T> {
-        CowArc { x: UnsafeArc::new(data) }
-    }
-
-    #[inline]
-    pub fn get<'a>(&'a self) -> &'a T {
-        unsafe { &*self.x.get_immut() }
-    }
-
-    /// get a mutable reference to the contents. If there are more then one
-    /// reference to the contents of the `CowArc` will be cloned
-    /// and this reference updated to point to the cloned data.
-    #[inline]
-    pub fn get_mut<'a>(&'a mut self) -> &'a mut T {
-        if !self.x.is_owned() {
-            *self = CowArc::new(self.get().clone())
-        }
-        unsafe { &mut *self.x.get() }
-    }
-}
-
-impl<T:Clone+Send+Freeze> Clone for CowArc<T> {
-    /// Duplicate a Copy-on-write Arc. See arc::clone for more details.
-    #[inline]
-    fn clone(&self) -> CowArc<T> {
-        CowArc { x: self.x.clone() }
-    }
-}
-
-
-
 /****************************************************************************
  * Tests
  ****************************************************************************/
@@ -1007,68 +963,4 @@ mod tests {
         // and I wasn't sure why :( . This is a mediocre "next best" option.
         for _ in range(0, 8) { test_rw_write_cond_downgrade_read_race_helper(); }
     }
-
-    #[test]
-    fn test_cowarc_clone()
-    {
-        let cow0 = CowArc::new(75u);
-        let cow1 = cow0.clone();
-        let cow2 = cow1.clone();
-
-        assert!(75 == *cow0.get());
-        assert!(75 == *cow1.get());
-        assert!(75 == *cow2.get());
-
-        assert!(cow0.get() == cow1.get());
-        assert!(cow0.get() == cow2.get());
-    }
-
-    #[test]
-    fn test_cowarc_clone_get_mut()
-    {
-        let mut cow0 = CowArc::new(75u);
-        let mut cow1 = cow0.clone();
-        let mut cow2 = cow1.clone();
-
-        assert!(75 == *cow0.get_mut());
-        assert!(75 == *cow1.get_mut());
-        assert!(75 == *cow2.get_mut());
-
-        *cow0.get_mut() += 1;
-        *cow1.get_mut() += 2;
-        *cow2.get_mut() += 3;
-
-        assert!(76 == *cow0.get());
-        assert!(77 == *cow1.get());
-        assert!(78 == *cow2.get());
-
-        // none should point to the same backing memory
-        assert!(cow0.get() != cow1.get());
-        assert!(cow0.get() != cow2.get());
-        assert!(cow1.get() != cow2.get());
-    }
-
-    #[test]
-    fn test_cowarc_clone_get_mut2()
-    {
-        let mut cow0 = CowArc::new(75u);
-        let cow1 = cow0.clone();
-        let cow2 = cow1.clone();
-
-        assert!(75 == *cow0.get());
-        assert!(75 == *cow1.get());
-        assert!(75 == *cow2.get());
-
-        *cow0.get_mut() += 1;
-
-        assert!(76 == *cow0.get());
-        assert!(75 == *cow1.get());
-        assert!(75 == *cow2.get());
-
-        // cow1 and cow2 should share the same contents
-        // cow0 should have a unique reference
-        assert!(cow0.get() != cow1.get());
-        assert!(cow0.get() != cow2.get());
-        assert!(cow1.get() == cow2.get());
-    }
 }

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

@@ -34,6 +34,11 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
+#[cfg(stage0)]
+macro_rules! if_ok (
+    ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
+)
+
 // Utility modules
 
 pub mod c_vec;
@@ -79,6 +84,8 @@ pub mod rational;
 pub mod complex;
 pub mod stats;
 pub mod hex;
+pub mod uuid;
+
 
 #[cfg(unicode)]
 mod unicode;

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

@@ -51,14 +51,10 @@ impl<T:Ord> PriorityQueue<T> {
     /// Returns the number of elements the queue can hold without reallocating
     pub fn capacity(&self) -> uint { self.data.capacity() }
 
-    /// Reserve capacity for exactly n elements in the PriorityQueue.
-    /// Do nothing if the capacity is already sufficient.
-    pub fn reserve_exact(&mut self, n: uint) { self.data.reserve_exact(n) }
-
-    /// Reserve capacity for at least n elements in the PriorityQueue.
-    /// Do nothing if the capacity is already sufficient.
-    pub fn reserve(&mut self, n: uint) {
-        self.data.reserve(n)
+    pub fn reserve(&mut self, n: uint) { self.data.reserve(n) }
+
+    pub fn reserve_at_least(&mut self, n: uint) {
+        self.data.reserve_at_least(n)
     }
 
     /// Pop the greatest item from the queue - fails if empty
@@ -207,7 +203,7 @@ impl<T: Ord> Extendable<T> for PriorityQueue<T> {
         let (lower, _) = iter.size_hint();
 
         let len = self.capacity();
-        self.reserve(len + lower);
+        self.reserve_at_least(len + lower);
 
         for elem in *iter {
             self.push(elem);

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

@@ -168,8 +168,8 @@ impl<T> RingBuf<T> {
     /// # Arguments
     ///
     /// * n - The number of elements to reserve space for
-    pub fn reserve_exact(&mut self, n: uint) {
-        self.elts.reserve_exact(n);
+    pub fn reserve(&mut self, n: uint) {
+        self.elts.reserve(n);
     }
 
     /// Reserve capacity for at least `n` elements in the given RingBuf,
@@ -182,8 +182,8 @@ impl<T> RingBuf<T> {
     /// # Arguments
     ///
     /// * n - The number of elements to reserve space for
-    pub fn reserve(&mut self, n: uint) {
-        self.elts.reserve(n);
+    pub fn reserve_at_least(&mut self, n: uint) {
+        self.elts.reserve_at_least(n);
     }
 
     /// Front-to-back iterator.
@@ -641,26 +641,26 @@ mod tests {
     }
 
     #[test]
-    fn test_reserve_exact() {
+    fn test_reserve() {
         let mut d = RingBuf::new();
         d.push_back(0u64);
-        d.reserve_exact(50);
+        d.reserve(50);
         assert_eq!(d.elts.capacity(), 50);
         let mut d = RingBuf::new();
         d.push_back(0u32);
-        d.reserve_exact(50);
+        d.reserve(50);
         assert_eq!(d.elts.capacity(), 50);
     }
 
     #[test]
-    fn test_reserve() {
+    fn test_reserve_at_least() {
         let mut d = RingBuf::new();
         d.push_back(0u64);
-        d.reserve(50);
+        d.reserve_at_least(50);
         assert_eq!(d.elts.capacity(), 64);
         let mut d = RingBuf::new();
         d.push_back(0u32);
-        d.reserve(50);
+        d.reserve_at_least(50);
         assert_eq!(d.elts.capacity(), 64);
     }