---

yaml
---
r: 148879
b: refs/heads/try2
c: b69c81c
h: refs/heads/master
i:
  148877: 34b365f
  148875: ddc5f9f
  148871: a5441fe
  148863: 8e5fac5
v: v3

Author: joaoxsouls

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2877928b22c239849a79b48d07139104ff144cd4
+refs/heads/try2: b69c81c9e0ad3ad1f38ba1874c3252d9c561b331
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/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/try2/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/try2/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/try2/src/libsemver/lib.rs renamed to branches/try2/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/try2/src/libextra/sync/mod.rs

@@ -19,11 +19,11 @@
 
 use std::cast;
 use std::comm;
-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;
 
@@ -191,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 nopod: marker::NoPod,
+    priv token: util::NonCopyable,
 }
 
 impl<'a> Condvar<'a> {
@@ -334,7 +334,7 @@ impl Sem<~[WaitQueue]> {
             blk(&Condvar {
                 sem: self,
                 order: Nothing,
-                nopod: marker::NoPod
+                token: NonCopyable
             })
         })
     }
@@ -574,7 +574,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 +609,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 +662,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 +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),
-                       nopod: marker::NoPod })
+                       token: NonCopyable })
     }
 }
 

branches/try2/src/libstd/cell.rs

@@ -12,7 +12,8 @@
 
 use prelude::*;
 use cast;
-use kinds::{marker, Pod};
+use util::NonCopyable;
+use kinds::{marker,Pod};
 
 /// A mutable memory location that admits only `Pod` data.
 pub struct Cell<T> {
@@ -56,9 +57,9 @@ impl<T:Pod> Clone for Cell<T> {
 pub struct RefCell<T> {
     priv value: T,
     priv borrow: BorrowFlag,
+    priv nc: NonCopyable,
     priv marker1: marker::InvariantType<T>,
     priv marker2: marker::NoFreeze,
-    priv marker3: marker::NoPod,
 }
 
 // Values [1, MAX-1] represent the number of `Ref` active
@@ -73,9 +74,9 @@ impl<T> RefCell<T> {
         RefCell {
             marker1: marker::InvariantType::<T>,
             marker2: marker::NoFreeze,
-            marker3: marker::NoPod,
             value: value,
             borrow: UNUSED,
+            nc: NonCopyable
         }
     }
 

branches/try2/src/libstd/option.rs

@@ -481,7 +481,6 @@ mod tests {
     use iter::range;
     use str::StrSlice;
     use util;
-    use kinds::marker;
     use vec::ImmutableVector;
 
     #[test]
@@ -552,7 +551,7 @@ mod tests {
 
     #[test] #[should_fail]
     fn test_option_too_much_dance() {
-        let mut y = Some(marker::NoPod);
+        let mut y = Some(util::NonCopyable);
         let _y2 = y.take_unwrap();
         let _y3 = y.take_unwrap();
     }