---

yaml
---
r: 44758
b: refs/heads/master
c: b79c4dc
h: refs/heads/master
v: v3

Author: youknowone

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9b08cd4903f7b3b5bb193dec85b055f24ff09cb7
+refs/heads/master: b79c4dc262227f0d09706a13f76fdb347ca6d70d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/core.rc

@@ -51,7 +51,6 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_self)];
-#[allow(deprecated_mutable_fields)];
 
 /* The Prelude. */
 
@@ -143,7 +142,6 @@ pub mod dlist;
 #[path="iter-trait.rs"] #[merge = "iter-trait/dlist.rs"]
 pub mod dlist_iter;
 pub mod hashmap;
-pub mod cell;
 
 
 /* Tasks and communication */

trunk/src/libcore/pipes.rs

@@ -86,7 +86,6 @@ bounded and unbounded protocols allows for less code duplication.
 
 use cmp::Eq;
 use cast::{forget, reinterpret_cast, transmute};
-use cell::Cell;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use libc;
@@ -918,9 +917,11 @@ pub fn spawn_service<T:Owned,Tb:Owned>(
 
     // This is some nasty gymnastics required to safely move the pipe
     // into a new task.
-    let server = Cell(server);
-    do task::spawn {
-        service(server.take());
+    let server = ~mut Some(server);
+    do task::spawn || {
+        let mut server_ = None;
+        server_ <-> *server;
+        service(option::unwrap(server_))
     }
 
     client
@@ -940,9 +941,11 @@ pub fn spawn_service_recv<T:Owned,Tb:Owned>(
 
     // This is some nasty gymnastics required to safely move the pipe
     // into a new task.
-    let server = Cell(server);
-    do task::spawn {
-        service(server.take())
+    let server = ~mut Some(server);
+    do task::spawn || {
+        let mut server_ = None;
+        server_ <-> *server;
+        service(option::unwrap(server_))
     }
 
     client

trunk/src/libcore/private.rs

@@ -107,14 +107,10 @@ fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
  * Shared state & exclusive ARC
  ****************************************************************************/
 
-struct UnwrapProtoInner {
-    contents: Option<(comm::ChanOne<()>,  comm::PortOne<bool>)>,
-}
-
 // An unwrapper uses this protocol to communicate with the "other" task that
 // drops the last refcount on an arc. Unfortunately this can't be a proper
 // pipe protocol because the unwrapper has to access both stages at once.
-type UnwrapProto = ~UnwrapProtoInner;
+type UnwrapProto = ~mut Option<(comm::ChanOne<()>,  comm::PortOne<bool>)>;
 
 struct ArcData<T> {
     mut count:     libc::intptr_t,
@@ -143,10 +139,9 @@ struct ArcDestruct<T> {
                     // reference. In effect, being here means we're the only
                     // *awake* task with the data.
                     if data.unwrapper != 0 {
-                        let mut p: UnwrapProto =
+                        let p: UnwrapProto =
                             cast::reinterpret_cast(&data.unwrapper);
-                        let (message, response) =
-                            option::swap_unwrap(&mut p.contents);
+                        let (message, response) = option::swap_unwrap(p);
                         // Send 'ready' and wait for a response.
                         comm::send_one(message, ());
                         // Unkillable wait. Message guaranteed to come.
@@ -201,9 +196,7 @@ pub unsafe fn unwrap_shared_mutable_state<T:Owned>(rc: SharedMutableState<T>)
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&rc.data);
         let (p1,c1) = comm::oneshot(); // ()
         let (p2,c2) = comm::oneshot(); // bool
-        let mut server: UnwrapProto = ~UnwrapProtoInner {
-            contents: Some((c1,p2))
-        };
+        let server: UnwrapProto = ~mut Some((c1,p2));
         let serverp: int = cast::transmute(server);
         // Try to put our server end in the unwrapper slot.
         if compare_and_swap(&mut ptr.unwrapper, 0, serverp) {
@@ -416,9 +409,8 @@ pub fn unwrap_exclusive<T:Owned>(arc: Exclusive<T>) -> T {
 pub mod tests {
     use core::option::{None, Some};
 
-    use cell::Cell;
-    use comm;
     use option;
+    use comm;
     use private::{exclusive, unwrap_exclusive};
     use result;
     use task;
@@ -431,7 +423,7 @@ pub mod tests {
         let num_tasks = 10;
         let count = 10;
 
-        let total = exclusive(~0);
+        let total = exclusive(~mut 0);
 
         for uint::range(0, num_tasks) |_i| {
             let total = total.clone();
@@ -480,20 +472,21 @@ pub mod tests {
     #[test]
     pub fn exclusive_unwrap_contended() {
         let x = exclusive(~~"hello");
-        let x2 = Cell(x.clone());
-        do task::spawn {
-            let x2 = x2.take();
+        let x2 = ~mut Some(x.clone());
+        do task::spawn || {
+            let x2 = option::swap_unwrap(x2);
             do x2.with |_hello| { }
             task::yield();
         }
         assert unwrap_exclusive(x) == ~~"hello";
 
         // Now try the same thing, but with the child task blocking.
         let x = exclusive(~~"hello");
-        let x2 = Cell(x.clone());
+        let x2 = ~mut Some(x.clone());
         let mut res = None;
-        do task::task().future_result(|+r| res = Some(r)).spawn {
-            let x2 = x2.take();
+        do task::task().future_result(|+r| res = Some(r)).spawn
+              || {
+            let x2 = option::swap_unwrap(x2);
             assert unwrap_exclusive(x2) == ~~"hello";
         }
         // Have to get rid of our reference before blocking.
@@ -505,10 +498,11 @@ pub mod tests {
     #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn exclusive_unwrap_conflict() {
         let x = exclusive(~~"hello");
-        let x2 = Cell(x.clone());
+        let x2 = ~mut Some(x.clone());
         let mut res = None;
-        do task::task().future_result(|+r| res = Some(r)).spawn {
-            let x2 = x2.take();
+        do task::task().future_result(|+r| res = Some(r)).spawn
+           || {
+            let x2 = option::swap_unwrap(x2);
             assert unwrap_exclusive(x2) == ~~"hello";
         }
         assert unwrap_exclusive(x) == ~~"hello";

trunk/src/libcore/private/weak_task.rs

@@ -18,17 +18,16 @@ it is running, sending a notification to the task that the runtime
 is trying to shut down.
 */
 
-use cell::Cell;
-use comm::{GenericSmartChan, stream};
-use comm::{Port, Chan, SharedChan, GenericChan, GenericPort};
-use hashmap::linear::LinearMap;
-use ops::Drop;
 use option::{Some, None, swap_unwrap};
 use private::at_exit::at_exit;
-use private::finally::Finally;
 use private::global::global_data_clone_create;
-use task::rt::{task_id, get_task_id};
+use private::finally::Finally;
+use comm::{Port, Chan, SharedChan, GenericChan,
+           GenericPort, GenericSmartChan, stream};
 use task::{Task, task, spawn};
+use task::rt::{task_id, get_task_id};
+use hashmap::linear::LinearMap;
+use ops::Drop;
 
 type ShutdownMsg = ();
 
@@ -38,13 +37,14 @@ pub unsafe fn weaken_task(f: &fn(Port<ShutdownMsg>)) {
     let service = global_data_clone_create(global_data_key,
                                            create_global_service);
     let (shutdown_port, shutdown_chan) = stream::<ShutdownMsg>();
-    let shutdown_port = Cell(shutdown_port);
+    let shutdown_port = ~mut Some(shutdown_port);
     let task = get_task_id();
     // Expect the weak task service to be alive
     assert service.try_send(RegisterWeakTask(task, shutdown_chan));
     unsafe { rust_dec_kernel_live_count(); }
     do fn&() {
-        f(shutdown_port.take())
+        let shutdown_port = swap_unwrap(&mut *shutdown_port);
+        f(shutdown_port)
     }.finally || {
         unsafe { rust_inc_kernel_live_count(); }
         // Service my have already exited
@@ -67,15 +67,16 @@ fn create_global_service() -> ~WeakTaskService {
 
     debug!("creating global weak task service");
     let (port, chan) = stream::<ServiceMsg>();
-    let port = Cell(port);
+    let port = ~mut Some(port);
     let chan = SharedChan(chan);
     let chan_clone = chan.clone();
 
     do task().unlinked().spawn {
         debug!("running global weak task service");
-        let port = Cell(port.take());
+        let port = swap_unwrap(&mut *port);
+        let port = ~mut Some(port);
         do fn&() {
-            let port = port.take();
+            let port = swap_unwrap(&mut *port);
             // The weak task service is itself a weak task
             debug!("weakening the weak service task");
             unsafe { rust_dec_kernel_live_count(); }

trunk/src/libcore/repr.rs

@@ -602,6 +602,7 @@ fn test_repr() {
     exact_test(&(@10), "@10");
     exact_test(&(@mut 10), "@10");
     exact_test(&(~10), "~10");
+    exact_test(&(~mut 10), "~mut 10");
     exact_test(&(&10), "&10");
     let mut x = 10;
     exact_test(&(&mut x), "&mut 10");

trunk/src/libcore/task/mod.rs

@@ -34,7 +34,6 @@
  */
 
 use cast;
-use cell::Cell;
 use cmp;
 use cmp::Eq;
 use iter;
@@ -398,9 +397,9 @@ impl TaskBuilder {
     }
     /// Runs a task, while transfering ownership of one argument to the child.
     fn spawn_with<A:Owned>(arg: A, f: fn~(v: A)) {
-        let arg = Cell(arg);
-        do self.spawn {
-            f(arg.take());
+        let arg = ~mut Some(arg);
+        do self.spawn || {
+            f(option::swap_unwrap(arg))
         }
     }
 

trunk/src/libcore/task/spawn.rs

@@ -73,7 +73,6 @@
 #[doc(hidden)]; // FIXME #3538
 
 use cast;
-use cell::Cell;
 use container::Map;
 use option;
 use comm::{Chan, GenericChan, GenericPort, Port, stream};
@@ -531,11 +530,11 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) {
         gen_child_taskgroup(opts.linked, opts.supervised);
 
     unsafe {
-        let child_data = Cell((child_tg, ancestors, f));
+        let child_data = ~mut Some((child_tg, ancestors, f));
         // Being killed with the unsafe task/closure pointers would leak them.
         do unkillable {
             // Agh. Get move-mode items into the closure. FIXME (#2829)
-            let (child_tg, ancestors, f) = child_data.take();
+            let (child_tg, ancestors, f) = option::swap_unwrap(child_data);
             // Create child task.
             let new_task = match opts.sched.mode {
                 DefaultScheduler => rt::new_task(),
@@ -572,10 +571,10 @@ pub fn spawn_raw(opts: TaskOpts, f: fn~()) {
                           ancestors: AncestorList, is_main: bool,
                           notify_chan: Option<Chan<TaskResult>>,
                           f: fn~()) -> fn~() {
-        let child_data = Cell((child_arc, ancestors));
+        let child_data = ~mut Some((child_arc, ancestors));
         return fn~() {
             // Agh. Get move-mode items into the closure. FIXME (#2829)
-            let mut (child_arc, ancestors) = child_data.take();
+            let mut (child_arc, ancestors) = option::swap_unwrap(child_data);
             // Child task runs this code.
 
             // Even if the below code fails to kick the child off, we must

trunk/src/librustc/middle/check_match.rs

@@ -101,7 +101,11 @@ pub fn check_expr(cx: @MatchCheckCtxt, ex: @expr, &&s: (), v: visit::vt<()>) {
           _ => { /* We assume only enum types can be uninhabited */ }
        }
        let arms = vec::concat(arms.filter_mapped(unguarded_pat));
-       check_exhaustive(cx, ex.span, arms);
+       if arms.is_empty() {
+           cx.tcx.sess.span_err(ex.span, ~"non-exhaustive patterns");
+       } else {
+           check_exhaustive(cx, ex.span, arms);
+       }
      }
      _ => ()
     }

trunk/src/librustc/middle/lint.rs

@@ -80,7 +80,6 @@ pub enum lint {
     type_limits,
     default_methods,
     deprecated_self,
-    deprecated_mutable_fields,
 
     managed_heap_memory,
     owned_heap_memory,
@@ -255,13 +254,6 @@ pub fn get_lint_dict() -> LintDict {
             default: warn
          }),
 
-        (@~"deprecated_mutable_fields",
-         @LintSpec {
-            lint: deprecated_mutable_fields,
-            desc: "deprecated mutable fields in structures",
-            default: deny
-        }),
-
         /* FIXME(#3266)--make liveness warnings lintable
         (@~"unused_variable",
          @LintSpec {
@@ -494,7 +486,6 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
     check_item_type_limits(cx, i);
     check_item_default_methods(cx, i);
     check_item_deprecated_self(cx, i);
-    check_item_deprecated_mutable_fields(cx, i);
 }
 
 // Take a visitor, and modify it so that it will not proceed past subitems.
@@ -712,26 +703,6 @@ fn check_item_deprecated_self(cx: ty::ctxt, item: @ast::item) {
     }
 }
 
-fn check_item_deprecated_mutable_fields(cx: ty::ctxt, item: @ast::item) {
-    match item.node {
-        ast::item_struct(struct_def, _) => {
-            for struct_def.fields.each |field| {
-                match field.node.kind {
-                    ast::named_field(_, ast::struct_mutable, _) => {
-                        cx.sess.span_lint(deprecated_mutable_fields,
-                                          item.id,
-                                          item.id,
-                                          field.span,
-                                          ~"mutable fields are deprecated");
-                    }
-                    ast::named_field(*) | ast::unnamed_field => {}
-                }
-            }
-        }
-        _ => {}
-    }
-}
-
 fn check_item_structural_records(cx: ty::ctxt, it: @ast::item) {
     let visit = item_stopping_visitor(
         visit::mk_simple_visitor(@visit::SimpleVisitor {