refactor: Remove wrapping cell

Author: k-nasa

src/rt/runtime.rs

@@ -219,7 +219,7 @@ impl Machine {
                 runs = 0;
                 rt.quick_poll().unwrap();
 
-                let p = self.processor.lock();
+                let mut p = self.processor.lock();
                 if let Steal::Success(task) = p.steal_from_global(rt) {
                     p.schedule(rt, task);
                 }
@@ -284,21 +284,21 @@ struct Processor {
     worker: Worker<Runnable>,
 
     /// Contains the next task to run as an optimization that skips the queue.
-    slot: Cell<Option<Runnable>>,
+    slot: Option<Runnable>,
 }
 
 impl Processor {
     /// Creates a new processor.
     fn new() -> Processor {
         Processor {
             worker: Worker::new_fifo(),
-            slot: Cell::new(None),
+            slot: None,
         }
     }
 
     /// Schedules a task to run on this processor.
-    fn schedule(&self, rt: &Runtime, task: Runnable) {
-        match self.slot.replace(Some(task)) {
+    fn schedule(&mut self, rt: &Runtime, task: Runnable) {
+        match self.slot.replace(task) {
             None => {}
             Some(task) => {
                 self.worker.push(task);
@@ -308,15 +308,15 @@ impl Processor {
     }
 
     /// Flushes a task from the slot into the local queue.
-    fn flush_slot(&self, rt: &Runtime) {
+    fn flush_slot(&mut self, rt: &Runtime) {
         if let Some(task) = self.slot.take() {
             self.worker.push(task);
             rt.notify();
         }
     }
 
     /// Pops a task from this processor.
-    fn pop_task(&self) -> Option<Runnable> {
+    fn pop_task(&mut self) -> Option<Runnable> {
         self.slot.take().or_else(|| self.worker.pop())
     }