---

yaml
---
r: 106219
b: refs/heads/auto
c: e46e933
h: refs/heads/master
i:
  106217: 9a5f61a
  106215: 19b9ff3
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 841f31ecf942531b54c8ee991924aa969666ee72
+refs/heads/auto: e46e9332d9574790ccf41ae56ffa1010c4267ba1
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/runtest.rs

@@ -337,7 +337,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                 }
             }
 
-            if tool_path.is_empty() {
+            if tool_path.equals(&~"") {
                 fatal(~"cannot found android cross path");
             }
 
@@ -452,7 +452,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
         let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
         let new_options = split_maybe_args(options).move_iter()
                                                    .filter(|x| !options_to_remove.contains(x))
-                                                   .collect::<~[~str]>()
+                                                   .to_owned_vec()
                                                    .connect(" ");
         Some(new_options)
     }

branches/auto/src/doc/guide-tasks.md

@@ -493,14 +493,14 @@ Here is the function that implements the child task:
 ~~~
 extern crate sync;
 # fn main() {
-fn stringifier(channel: &sync::DuplexStream<~str, uint>) {
-    let mut value: uint;
-    loop {
-        value = channel.recv();
-        channel.send(value.to_str());
-        if value == 0 { break; }
+    fn stringifier(channel: &sync::DuplexStream<~str, uint>) {
+        let mut value: uint;
+        loop {
+            value = channel.recv();
+            channel.send(value.to_str());
+            if value == 0 { break; }
+        }
     }
-}
 # }
 ~~~~
 

branches/auto/src/doc/rust.md

@@ -1019,7 +1019,7 @@ never invoking this behaviour or exposing an API making it possible for it to oc
 
 * Data races
 * Dereferencing a null/dangling raw pointer
-* Mutating an immutable value/reference
+* Mutating an immutable value/reference, if it is not marked as non-`Freeze`
 * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values) (uninitialized) memory
 * Breaking the [pointer aliasing rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
   with raw pointers (a subset of the rules used by C)
@@ -3434,6 +3434,10 @@ call to the method `make_string`.
 Types in Rust are categorized into kinds, based on various properties of the components of the type.
 The kinds are:
 
+`Freeze`
+  : Types of this kind are deeply immutable;
+    they contain no mutable memory locations
+    directly or indirectly via pointers.
 `Send`
   : Types of this kind can be safely sent between tasks.
     This kind includes scalars, owning pointers, owned closures, and

branches/auto/src/doc/tutorial.md

@@ -2099,6 +2099,10 @@ unless they contain managed boxes, managed closures, or references.
 These are types that are safe to be used across several threads with access to
 a `&T` pointer. `MutexArc` is an example of a *sharable* type with internal mutable data.
 
+* `Freeze` - Constant (immutable) types.
+These are types that do not contain anything intrinsically mutable.
+Intrinsically mutable values include `Cell` in the standard library.
+
 * `'static` - Non-borrowed types.
 These are types that do not contain any data whose lifetime is bound to
 a particular stack frame. These are types that do not contain any
@@ -2148,7 +2152,7 @@ We say that the `Printable` trait _provides_ a `print` method with the
 given signature.  This means that we can call `print` on an argument
 of any type that implements the `Printable` trait.
 
-Rust's built-in `Send` and `Share` types are examples of traits that
+Rust's built-in `Send` and `Freeze` types are examples of traits that
 don't provide any methods.
 
 Traits may be implemented for specific types with [impls]. An impl for
@@ -2440,15 +2444,15 @@ Consequently, the trait objects themselves automatically fulfill their
 respective kind bounds. However, this default behavior can be overridden by
 specifying a list of bounds on the trait type, for example, by writing `~Trait:`
 (which indicates that the contents of the owned trait need not fulfill any
-bounds), or by writing `~Trait:Send+Share`, which indicates that in addition
-to fulfilling `Send`, contents must also fulfill `Share`, and as a consequence,
-the trait itself fulfills `Share`.
+bounds), or by writing `~Trait:Send+Freeze`, which indicates that in addition
+to fulfilling `Send`, contents must also fulfill `Freeze`, and as a consequence,
+the trait itself fulfills `Freeze`.
 
 * `~Trait:Send` is equivalent to `~Trait`.
 * `&Trait:` is equivalent to `&Trait`.
 
 Builtin kind bounds can also be specified on closure types in the same way (for
-example, by writing `fn:Send()`), and the default behaviours are the same as
+example, by writing `fn:Freeze()`), and the default behaviours are the same as
 for traits of the same storage class.
 
 ## Trait inheritance

branches/auto/src/driver/driver.rs

@@ -8,6 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[no_uv]; // remove this after stage0
+#[allow(attribute_usage)]; // remove this after stage0
+extern crate native; // remove this after stage0
+
 #[cfg(rustdoc)]
 extern crate this = "rustdoc";
 

branches/auto/src/libarena/lib.rs

@@ -24,6 +24,7 @@
       html_root_url = "http://static.rust-lang.org/doc/master")];
 #[allow(missing_doc)];
 #[feature(managed_boxes)];
+#[allow(deprecated_owned_vector)]; // NOTE: remove after stage0
 
 extern crate collections;
 
@@ -36,6 +37,7 @@ use std::mem;
 use std::ptr::read;
 use std::cmp;
 use std::num;
+use std::kinds::marker;
 use std::rc::Rc;
 use std::rt::global_heap;
 use std::intrinsics::{TyDesc, get_tydesc};
@@ -52,11 +54,11 @@ struct Chunk {
 }
 impl Chunk {
     fn capacity(&self) -> uint {
-        self.data.borrow().capacity()
+        self.data.deref().borrow().get().capacity()
     }
 
     unsafe fn as_ptr(&self) -> *u8 {
-        self.data.borrow().as_ptr()
+        self.data.deref().borrow().get().as_ptr()
     }
 }
 
@@ -88,6 +90,7 @@ pub struct Arena {
     priv head: Chunk,
     priv pod_head: Chunk,
     priv chunks: RefCell<@List<Chunk>>,
+    priv no_freeze: marker::NoFreeze,
 }
 
 impl Arena {
@@ -100,6 +103,7 @@ impl Arena {
             head: chunk(initial_size, false),
             pod_head: chunk(initial_size, true),
             chunks: RefCell::new(@Nil),
+            no_freeze: marker::NoFreeze,
         }
     }
 }

branches/auto/src/libcollections/btree.rs

@@ -94,11 +94,16 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> {
     fn eq(&self, other: &BTree<K, V>) -> bool {
-        self.root.cmp(&other.root) == Equal
+        self.equals(other)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {}
+impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {
+    ///Testing equality on BTrees by comparing the root.
+    fn equals(&self, other: &BTree<K, V>) -> bool {
+        self.root.cmp(&other.root) == Equal
+    }
+}
 
 impl<K: TotalOrd, V: TotalEq> Ord for BTree<K, V> {
     fn lt(&self, other: &BTree<K, V>) -> bool {
@@ -199,6 +204,14 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> {
     fn eq(&self, other: &Node<K, V>) -> bool {
+        self.equals(other)
+    }
+}
+
+impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {
+    ///Returns whether two nodes are equal based on the keys of each element.
+    ///Two nodes are equal if all of their keys are the same.
+    fn equals(&self, other: &Node<K, V>) -> bool{
         match *self{
             BranchNode(ref branch) => {
                 if other.is_leaf() {
@@ -219,8 +232,6 @@ impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> {
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {}
-
 impl<K: TotalOrd, V: TotalEq> Ord for Node<K, V> {
     fn lt(&self, other: &Node<K, V>) -> bool {
         self.cmp(other) == Less
@@ -394,11 +405,16 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Leaf<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> {
     fn eq(&self, other: &Leaf<K, V>) -> bool {
-        self.elts == other.elts
+        self.equals(other)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {}
+impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {
+    ///Implementation of equals function for leaves that compares LeafElts.
+    fn equals(&self, other: &Leaf<K, V>) -> bool {
+        self.elts.equals(&other.elts)
+    }
+}
 
 impl<K: TotalOrd, V: TotalEq> Ord for Leaf<K, V> {
     fn lt(&self, other: &Leaf<K, V>) -> bool {
@@ -623,11 +639,16 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Branch<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> {
     fn eq(&self, other: &Branch<K, V>) -> bool {
-        self.elts == other.elts
+        self.equals(other)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {}
+impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {
+    ///Equals function for Branches--compares all the elements in each branch
+    fn equals(&self, other: &Branch<K, V>) -> bool {
+        self.elts.equals(&other.elts)
+    }
+}
 
 impl<K: TotalOrd, V: TotalEq> Ord for Branch<K, V> {
     fn lt(&self, other: &Branch<K, V>) -> bool {
@@ -691,11 +712,16 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for LeafElt<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> {
     fn eq(&self, other: &LeafElt<K, V>) -> bool {
-        self.key == other.key && self.value == other.value
+        self.equals(other)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {}
+impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {
+    ///TotalEq for LeafElts
+    fn equals(&self, other: &LeafElt<K, V>) -> bool {
+        self.key.equals(&other.key) && self.value.equals(&other.value)
+    }
+}
 
 impl<K: TotalOrd, V: TotalEq> Ord for LeafElt<K, V> {
     fn lt(&self, other: &LeafElt<K, V>) -> bool {
@@ -740,11 +766,16 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
 
 impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{
     fn eq(&self, other: &BranchElt<K, V>) -> bool {
-        self.key == other.key && self.value == other.value
+        self.equals(other)
     }
 }
 
-impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{}
+impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{
+    ///TotalEq for BranchElts
+    fn equals(&self, other: &BranchElt<K, V>) -> bool {
+        self.key.equals(&other.key)&&self.value.equals(&other.value)
+    }
+}
 
 impl<K: TotalOrd, V: TotalEq> Ord for BranchElt<K, V> {
     fn lt(&self, other: &BranchElt<K, V>) -> bool {
@@ -869,7 +900,7 @@ mod test_btree {
     fn btree_clone_test() {
         let b = BTree::new(1, ~"abc", 2);
         let b2 = b.clone();
-        assert!(b.root == b2.root)
+        assert!(b.root.equals(&b2.root))
     }
 
     //Tests the BTree's cmp() method when one node is "less than" another.

branches/auto/src/libcollections/enum_set.rs

@@ -15,7 +15,7 @@
 
 use std::num::Bitwise;
 
-#[deriving(Clone, Eq, TotalEq, Hash, Show)]
+#[deriving(Clone, Eq, Hash, Show)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set