green,native,rustuv: Replace many pointer transmute's with as or referencing.

These can all be written in a more controlled manner than with the
transmute hammer, leading to (hopefully) safer code.

src/libgreen/context.rs

@@ -289,11 +289,8 @@ fn initialize_call_frame(regs: &mut Registers, fptr: InitFn, arg: uint,
 }
 
 fn align_down(sp: *mut uint) -> *mut uint {
-    unsafe {
-        let sp: uint = transmute(sp);
-        let sp = sp & !(16 - 1);
-        transmute::<uint, *mut uint>(sp)
-    }
+    let sp = (sp as uint) & !(16 - 1);
+    sp as *mut uint
 }
 
 // ptr::mut_offset is positive ints only

src/libgreen/sched.rs

@@ -612,9 +612,7 @@ impl Scheduler {
                                f: |&mut Scheduler, ~GreenTask|) -> ~GreenTask {
         let f_opaque = ClosureConverter::from_fn(f);
 
-        let current_task_dupe = unsafe {
-            *cast::transmute::<&~GreenTask, &uint>(&current_task)
-        };
+        let current_task_dupe = &*current_task as *GreenTask;
 
         // The current task is placed inside an enum with the cleanup
         // function. This enum is then placed inside the scheduler.
@@ -633,13 +631,8 @@ impl Scheduler {
                 cast::transmute_mut_region(*next_task.sched.get_mut_ref());
 
             let current_task: &mut GreenTask = match sched.cleanup_job {
-                Some(CleanupJob { task: ref task, .. }) => {
-                    let task_ptr: *~GreenTask = task;
-                    cast::transmute_mut_region(*cast::transmute_mut_unsafe(task_ptr))
-                }
-                None => {
-                    rtabort!("no cleanup job");
-                }
+                Some(CleanupJob { task: ref mut task, .. }) => &mut **task,
+                None => rtabort!("no cleanup job")
             };
 
             let (current_task_context, next_task_context) =
@@ -852,7 +845,7 @@ impl Scheduler {
 
     // * Utility Functions
 
-    pub fn sched_id(&self) -> uint { unsafe { cast::transmute(self) } }
+    pub fn sched_id(&self) -> uint { self as *Scheduler as uint }
 
     pub fn run_cleanup_job(&mut self) {
         let cleanup_job = self.cleanup_job.take_unwrap();

src/libgreen/task.rs

@@ -266,7 +266,7 @@ impl GreenTask {
     // context switches
 
     pub fn as_uint(&self) -> uint {
-        unsafe { cast::transmute(self) }
+        self as *GreenTask as uint
     }
 
     pub unsafe fn from_uint(val: uint) -> ~GreenTask { cast::transmute(val) }

src/libnative/task.rs

@@ -186,7 +186,7 @@ impl rt::Runtime for Ops {
         cur_task.put_runtime(self as ~rt::Runtime);
 
         unsafe {
-            let cur_task_dupe = *cast::transmute::<&~Task, &uint>(&cur_task);
+            let cur_task_dupe = &*cur_task as *Task;
             let task = BlockedTask::block(cur_task);
 
             if times == 1 {
@@ -218,7 +218,7 @@ impl rt::Runtime for Ops {
                 }
             }
             // re-acquire ownership of the task
-            cur_task = cast::transmute::<uint, ~Task>(cur_task_dupe);
+            cur_task = cast::transmute(cur_task_dupe);
         }
 
         // put the task back in TLS, and everything is as it once was.

src/librustuv/queue.rs

@@ -123,7 +123,7 @@ impl QueuePool {
         unsafe {
             assert_eq!(uvll::uv_async_init(loop_.handle, handle, async_cb), 0);
             uvll::uv_unref(handle);
-            let data: *c_void = *cast::transmute::<&~QueuePool, &*c_void>(&q);
+            let data = &*q as *QueuePool as *c_void;
             uvll::set_data_for_uv_handle(handle, data);
         }