---

yaml
---
r: 152874
b: refs/heads/try2
c: dfef422
h: refs/heads/master
v: v3

Author: omasanori

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

branches/try2/src/libgreen/lib.rs

@@ -299,7 +299,7 @@ pub fn start(argc: int, argv: **u8,
     let mut ret = None;
     simple::task().run(|| {
         ret = Some(run(event_loop_factory, main.take_unwrap()));
-    }).destroy();
+    });
     // unsafe is ok b/c we're sure that the runtime is gone
     unsafe { rt::cleanup() }
     ret.unwrap()

branches/try2/src/libgreen/task.rs

@@ -110,7 +110,7 @@ extern fn bootstrap_green_task(task: uint, code: *(), env: *()) -> ! {
     // requested. This is the "try/catch" block for this green task and
     // is the wrapper for *all* code run in the task.
     let mut start = Some(start);
-    let task = task.swap().run(|| start.take_unwrap()()).destroy();
+    let task = task.swap().run(|| start.take_unwrap()());
 
     // Once the function has exited, it's time to run the termination
     // routine. This means we need to context switch one more time but
@@ -120,7 +120,7 @@ extern fn bootstrap_green_task(task: uint, code: *(), env: *()) -> ! {
     // this we could add a `terminate` function to the `Runtime` trait
     // in libstd, but that seems less appropriate since the coversion
     // method exists.
-    GreenTask::convert(task).terminate();
+    GreenTask::convert(task).terminate()
 }
 
 impl GreenTask {

branches/try2/src/libnative/io/process.rs

@@ -533,10 +533,6 @@ fn spawn_process_os(cfg: ProcessConfig,
 
     let dirp = cfg.cwd.map(|c| c.with_ref(|p| p)).unwrap_or(ptr::null());
 
-    let cfg = unsafe {
-        mem::transmute::<ProcessConfig,ProcessConfig<'static>>(cfg)
-    };
-
     with_envp(cfg.env, proc(envp) {
         with_argv(cfg.program, cfg.args, proc(argv) unsafe {
             let (mut input, mut output) = try!(pipe());

branches/try2/src/libnative/lib.rs

@@ -134,12 +134,13 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
     let mut main = Some(main);
     let mut task = task::new((my_stack_bottom, my_stack_top));
     task.name = Some(str::Slice("<main>"));
-    drop(task.run(|| {
+    let t = task.run(|| {
         unsafe {
             rt::stack::record_stack_bounds(my_stack_bottom, my_stack_top);
         }
         exit_code = Some(run(main.take_unwrap()));
-    }).destroy());
+    });
+    drop(t);
     unsafe { rt::cleanup(); }
     // If the exit code wasn't set, then the task block must have failed.
     return exit_code.unwrap_or(rt::DEFAULT_ERROR_CODE);

branches/try2/src/libnative/task.rs

@@ -92,7 +92,8 @@ pub fn spawn_opts(opts: TaskOpts, f: proc():Send) {
         let mut f = Some(f);
         let mut task = task;
         task.put_runtime(ops);
-        drop(task.run(|| { f.take_unwrap()() }).destroy());
+        let t = task.run(|| { f.take_unwrap()() });
+        drop(t);
         bookkeeping::decrement();
     })
 }

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

@@ -198,14 +198,8 @@ fn with_appropriate_checker(cx: &Context,
     let fty = ty::node_id_to_type(cx.tcx, id);
     match ty::get(fty).sty {
         ty::ty_closure(box ty::ClosureTy {
-            store: ty::UniqTraitStore,
-            bounds: mut bounds, ..
-        }) => {
-            // Procs can't close over non-static references!
-            bounds.add(ty::BoundStatic);
-
-            b(|cx, fv| check_for_uniq(cx, fv, bounds))
-        }
+            store: ty::UniqTraitStore, bounds, ..
+        }) => b(|cx, fv| check_for_uniq(cx, fv, bounds)),
 
         ty::ty_closure(box ty::ClosureTy {
             store: ty::RegionTraitStore(region, _), bounds, ..

branches/try2/src/librustrt/local_heap.rs

@@ -110,12 +110,7 @@ impl LocalHeap {
         self.memory_region.free(alloc);
     }
 
-    /// Immortalize all pending allocations, forcing them to live forever.
-    ///
-    /// This function will freeze all allocations to prevent all pending
-    /// allocations from being deallocated. This is used in preparation for when
-    /// a task is about to destroy TLD.
-    pub unsafe fn immortalize(&mut self) {
+    pub unsafe fn annihilate(&mut self) {
         let mut n_total_boxes = 0u;
 
         // Pass 1: Make all boxes immortal.
@@ -127,17 +122,6 @@ impl LocalHeap {
             (*alloc).ref_count = RC_IMMORTAL;
         });
 
-        if debug_mem() {
-            // We do logging here w/o allocation.
-            rterrln!("total boxes annihilated: {}", n_total_boxes);
-        }
-    }
-
-    /// Continues deallocation of the all pending allocations in this arena.
-    ///
-    /// This is invoked from the destructor, and requires that `immortalize` has
-    /// been called previously.
-    unsafe fn annihilate(&mut self) {
         // Pass 2: Drop all boxes.
         //
         // In this pass, unique-managed boxes may get freed, but not
@@ -158,6 +142,11 @@ impl LocalHeap {
         self.each_live_alloc(true, |me, alloc| {
             me.free(alloc);
         });
+
+        if debug_mem() {
+            // We do logging here w/o allocation.
+            rterrln!("total boxes annihilated: {}", n_total_boxes);
+        }
     }
 
     unsafe fn each_live_alloc(&mut self, read_next_before: bool,
@@ -181,7 +170,6 @@ impl LocalHeap {
 
 impl Drop for LocalHeap {
     fn drop(&mut self) {
-        unsafe { self.annihilate() }
         assert!(self.live_allocs.is_null());
     }
 }