---

yaml
---
r: 150194
b: refs/heads/try2
c: a73d2c7
h: refs/heads/master
v: v3

Author: Havvy

[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: 7e7a5e3d3eabe0ee46474b0eb701c159a45b490f
+refs/heads/try2: a73d2c70d4c24b85f3846d79b241ba1eb5f95e23
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/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/try2/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/try2/src/libarena/lib.rs

@@ -37,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};
@@ -89,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 {
@@ -101,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/try2/src/librustc/metadata/tydecode.rs

@@ -584,6 +584,9 @@ fn parse_bounds(st: &mut PState, conv: conv_did) -> ty::ParamBounds {
             'S' => {
                 param_bounds.builtin_bounds.add(ty::BoundSend);
             }
+            'K' => {
+                param_bounds.builtin_bounds.add(ty::BoundFreeze);
+            }
             'O' => {
                 param_bounds.builtin_bounds.add(ty::BoundStatic);
             }

branches/try2/src/librustc/metadata/tyencode.rs

@@ -392,6 +392,7 @@ fn enc_bounds(w: &mut MemWriter, cx: &ctxt, bs: &ty::ParamBounds) {
     for bound in bs.builtin_bounds.iter() {
         match bound {
             ty::BoundSend => mywrite!(w, "S"),
+            ty::BoundFreeze => mywrite!(w, "K"),
             ty::BoundStatic => mywrite!(w, "O"),
             ty::BoundSized => mywrite!(w, "Z"),
             ty::BoundPod => mywrite!(w, "P"),

branches/try2/src/librustc/middle/kind.rs

@@ -30,14 +30,20 @@ use syntax::visit::Visitor;
 // kind is noncopyable. The noncopyable kind can be extended with any number
 // of the following attributes.
 //
-//  Send: Things that can be sent on channels or included in spawned closures. It
-//  includes scalar types as well as classes and unique types containing only
-//  sendable types.
+//  send: Things that can be sent on channels or included in spawned closures.
+//  freeze: Things thare are deeply immutable. They are guaranteed never to
+//    change, and can be safely shared without copying between tasks.
 //  'static: Things that do not contain references.
 //
+// Send includes scalar types as well as classes and unique types containing
+// only sendable types.
+//
+// Freeze include scalar types, things without non-const fields, and pointers
+// to freezable things.
+//
 // This pass ensures that type parameters are only instantiated with types
 // whose kinds are equal or less general than the way the type parameter was
-// annotated (with the `Send` bound).
+// annotated (with the `Send` or `Freeze` bound).
 //
 // It also verifies that noncopyable kinds are not copied. Sendability is not
 // applied, since none of our language primitives send. Instead, the sending

branches/try2/src/librustc/middle/lang_items.rs

@@ -13,7 +13,7 @@
 // Language items are items that represent concepts intrinsic to the language
 // itself. Examples are:
 //
-// * Traits that specify "kinds"; e.g. "Share", "Send".
+// * Traits that specify "kinds"; e.g. "Freeze", "Send".
 //
 // * Traits that represent operators; e.g. "Add", "Sub", "Index".
 //
@@ -82,7 +82,9 @@ impl LanguageItems {
     }
 
     pub fn to_builtin_kind(&self, id: ast::DefId) -> Option<ty::BuiltinBound> {
-        if Some(id) == self.send_trait() {
+        if Some(id) == self.freeze_trait() {
+            Some(ty::BoundFreeze)
+        } else if Some(id) == self.send_trait() {
             Some(ty::BoundSend)
         } else if Some(id) == self.sized_trait() {
             Some(ty::BoundSized)
@@ -208,6 +210,7 @@ pub fn collect_language_items(krate: &ast::Crate,
 
 lets_do_this! {
 //  Variant name,                    Name,                      Method name;
+    FreezeTraitLangItem,             "freeze",                  freeze_trait;
     SendTraitLangItem,               "send",                    send_trait;
     SizedTraitLangItem,              "sized",                   sized_trait;
     PodTraitLangItem,                "pod",                     pod_trait;
@@ -272,6 +275,7 @@ lets_do_this! {
     ContravariantLifetimeItem,       "contravariant_lifetime",  contravariant_lifetime;
     InvariantLifetimeItem,           "invariant_lifetime",      invariant_lifetime;
 
+    NoFreezeItem,                    "no_freeze_bound",         no_freeze_bound;
     NoSendItem,                      "no_send_bound",           no_send_bound;
     NoPodItem,                       "no_pod_bound",            no_pod_bound;
     NoShareItem,                     "no_share_bound",          no_share_bound;

branches/try2/src/librustc/middle/ty.rs

@@ -838,6 +838,7 @@ pub type BuiltinBounds = EnumSet<BuiltinBound>;
 pub enum BuiltinBound {
     BoundStatic,
     BoundSend,
+    BoundFreeze,
     BoundSized,
     BoundPod,
     BoundShare,
@@ -851,6 +852,7 @@ pub fn AllBuiltinBounds() -> BuiltinBounds {
     let mut set = EnumSet::empty();
     set.add(BoundStatic);
     set.add(BoundSend);
+    set.add(BoundFreeze);
     set.add(BoundSized);
     set.add(BoundShare);
     set
@@ -1890,6 +1892,9 @@ def_type_content_sets!(
         //       that it neither reaches nor owns a managed pointer.
         Nonsendable                         = 0b0000_0111__0000_0100__0000,
 
+        // Things that prevent values from being considered freezable
+        Nonfreezable                        = 0b0000_1000__0000_0000__0000,
+
         // Things that prevent values from being considered 'static
         Nonstatic                           = 0b0000_0010__0000_0000__0000,
 
@@ -1924,6 +1929,7 @@ impl TypeContents {
     pub fn meets_bound(&self, cx: &ctxt, bb: BuiltinBound) -> bool {
         match bb {
             BoundStatic => self.is_static(cx),
+            BoundFreeze => self.is_freezable(cx),
             BoundSend => self.is_sendable(cx),
             BoundSized => self.is_sized(cx),
             BoundPod => self.is_pod(cx),
@@ -1959,6 +1965,10 @@ impl TypeContents {
         self.intersects(TC::OwnsOwned)
     }
 
+    pub fn is_freezable(&self, _: &ctxt) -> bool {
+        !self.intersects(TC::Nonfreezable)
+    }
+
     pub fn is_sized(&self, _: &ctxt) -> bool {
         !self.intersects(TC::Nonsized)
     }
@@ -2063,6 +2073,10 @@ pub fn type_is_sendable(cx: &ctxt, t: ty::t) -> bool {
     type_contents(cx, t).is_sendable(cx)
 }
 
+pub fn type_is_freezable(cx: &ctxt, t: ty::t) -> bool {
+    type_contents(cx, t).is_freezable(cx)
+}
+
 pub fn type_interior_is_unsafe(cx: &ctxt, t: ty::t) -> bool {
     type_contents(cx, t).interior_unsafe()
 }
@@ -2118,7 +2132,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
         cache.insert(ty_id, TC::None);
 
         let result = match get(ty).sty {
-            // Scalar and unique types are sendable, and durable
+            // Scalar and unique types are sendable, freezable, and durable
             ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
             ty_bare_fn(_) | ty::ty_char => {
                 TC::None
@@ -2256,7 +2270,9 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
                         did: ast::DefId,
                         tc: TypeContents)
                         -> TypeContents {
-        if Some(did) == cx.lang_items.no_send_bound() {
+        if Some(did) == cx.lang_items.no_freeze_bound() {
+            tc | TC::ReachesMutable
+        } else if Some(did) == cx.lang_items.no_send_bound() {
             tc | TC::ReachesNonsendAnnot
         } else if Some(did) == cx.lang_items.managed_bound() {
             tc | TC::Managed
@@ -2341,6 +2357,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
             tc = tc - match bound {
                 BoundStatic => TC::Nonstatic,
                 BoundSend => TC::Nonsendable,
+                BoundFreeze => TC::Nonfreezable,
                 BoundSized => TC::Nonsized,
                 BoundPod => TC::Nonpod,
                 BoundShare => TC::Nonsharable,

branches/try2/src/librustc/middle/typeck/collect.rs

@@ -976,7 +976,8 @@ pub fn ty_generics(ccx: &CrateCtxt,
          * Translate the AST's notion of ty param bounds (which are an
          * enum consisting of a newtyped Ty or a region) to ty's
          * notion of ty param bounds, which can either be user-defined
-         * traits, or the built-in trait (formerly known as kind): Send.
+         * traits, or one of the two built-in traits (formerly known
+         * as kinds): Freeze and Send.
          */
 
         let mut param_bounds = ty::ParamBounds {

branches/try2/src/librustc/util/ppaux.rs

@@ -664,6 +664,7 @@ impl Repr for ty::ParamBounds {
             res.push(match b {
                 ty::BoundStatic => ~"'static",
                 ty::BoundSend => ~"Send",
+                ty::BoundFreeze => ~"Freeze",
                 ty::BoundSized => ~"Sized",
                 ty::BoundPod => ~"Pod",
                 ty::BoundShare => ~"Share",
@@ -951,6 +952,7 @@ impl UserString for ty::BuiltinBound {
         match *self {
             ty::BoundStatic => ~"'static",
             ty::BoundSend => ~"Send",
+            ty::BoundFreeze => ~"Freeze",
             ty::BoundSized => ~"Sized",
             ty::BoundPod => ~"Pod",
             ty::BoundShare => ~"Share",

branches/try2/src/librustdoc/html/render.rs

@@ -116,8 +116,8 @@ pub enum Implementor {
 ///
 /// This structure purposefully does not implement `Clone` because it's intended
 /// to be a fairly large and expensive structure to clone. Instead this adheres
-/// to `Send` so it may be stored in a `Arc` instance and shared among the various
-/// rendering tasks.
+/// to both `Send` and `Freeze` so it may be stored in a `Arc` instance and
+/// shared among the various rendering tasks.
 pub struct Cache {
     /// Mapping of typaram ids to the name of the type parameter. This is used
     /// when pretty-printing a type (so pretty printing doesn't have to

branches/try2/src/libstd/cell.rs

@@ -22,15 +22,17 @@ use ty::Unsafe;
 /// A mutable memory location that admits only `Pod` data.
 pub struct Cell<T> {
     priv value: Unsafe<T>,
-    priv noshare: marker::NoShare,
+    priv marker1: marker::NoFreeze,
+    priv marker2: marker::NoShare,
 }
 
 impl<T:Pod> Cell<T> {
     /// Creates a new `Cell` containing the given value.
     pub fn new(value: T) -> Cell<T> {
         Cell {
             value: Unsafe::new(value),
-            noshare: marker::NoShare,
+            marker1: marker::NoFreeze,
+            marker2: marker::NoShare,
         }
     }
 
@@ -71,8 +73,9 @@ impl<T: fmt::Show> fmt::Show for Cell<T> {
 pub struct RefCell<T> {
     priv value: Unsafe<T>,
     priv borrow: BorrowFlag,
-    priv nopod: marker::NoPod,
-    priv noshare: marker::NoShare,
+    priv marker1: marker::NoFreeze,
+    priv marker2: marker::NoPod,
+    priv marker3: marker::NoShare,
 }
 
 // Values [1, MAX-1] represent the number of `Ref` active
@@ -85,9 +88,10 @@ impl<T> RefCell<T> {
     /// Create a new `RefCell` containing `value`
     pub fn new(value: T) -> RefCell<T> {
         RefCell {
+            marker1: marker::NoFreeze,
+            marker2: marker::NoPod,
+            marker3: marker::NoShare,
             value: Unsafe::new(value),
-            nopod: marker::NoPod,
-            noshare: marker::NoShare,
             borrow: UNUSED,
         }
     }

branches/try2/src/libstd/comm/mod.rs

@@ -291,7 +291,7 @@ pub struct Receiver<T> {
     priv inner: Flavor<T>,
     priv receives: Cell<uint>,
     // can't share in an arc
-    priv marker: marker::NoShare,
+    priv marker: marker::NoFreeze,
 }
 
 /// An iterator over messages on a receiver, this iterator will block
@@ -307,7 +307,7 @@ pub struct Sender<T> {
     priv inner: Flavor<T>,
     priv sends: Cell<uint>,
     // can't share in an arc
-    priv marker: marker::NoShare,
+    priv marker: marker::NoFreeze,
 }
 
 /// This enumeration is the list of the possible reasons that try_recv could not
@@ -340,7 +340,7 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
 
 impl<T: Send> Sender<T> {
     fn my_new(inner: Flavor<T>) -> Sender<T> {
-        Sender { inner: inner, sends: Cell::new(0), marker: marker::NoShare }
+        Sender { inner: inner, sends: Cell::new(0), marker: marker::NoFreeze }
     }
 
     /// Sends a value along this channel to be received by the corresponding
@@ -478,7 +478,7 @@ impl<T: Send> Drop for Sender<T> {
 
 impl<T: Send> Receiver<T> {
     fn my_new(inner: Flavor<T>) -> Receiver<T> {
-        Receiver { inner: inner, receives: Cell::new(0), marker: marker::NoShare }
+        Receiver { inner: inner, receives: Cell::new(0), marker: marker::NoFreeze }
     }
 
     /// Blocks waiting for a value on this receiver