librustc: Remove `ptr::addr_of`.

9 files changed, 98 insertions, 108 deletions

diff --git a/src/libstd/dbg.rs b/src/libstd/dbg.rs
index 0b297e9e6ba..34dd6390ecc 100644
--- a/src/libstd/dbg.rs
+++ b/src/libstd/dbg.rs
@@ -11,7 +11,6 @@
 //! Unsafe debugging functions for inspecting values.
 
 use core::cast::transmute;
-use core::ptr;
 use core::sys;
 
 pub mod rustrt {
@@ -37,36 +36,31 @@ pub fn debug_tydesc<T>() {
 
 pub fn debug_opaque<T>(x: T) {
     unsafe {
-        rustrt::debug_opaque(sys::get_type_desc::<T>(),
-                             ptr::addr_of(&x) as *());
+        rustrt::debug_opaque(sys::get_type_desc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_box<T>(x: @T) {
     unsafe {
-        rustrt::debug_box(sys::get_type_desc::<T>(),
-                          ptr::addr_of(&x) as *());
+        rustrt::debug_box(sys::get_type_desc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_tag<T>(x: T) {
     unsafe {
-        rustrt::debug_tag(sys::get_type_desc::<T>(),
-                          ptr::addr_of(&x) as *());
+        rustrt::debug_tag(sys::get_type_desc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_fn<T>(x: T) {
     unsafe {
-        rustrt::debug_fn(sys::get_type_desc::<T>(),
-                         ptr::addr_of(&x) as *());
+        rustrt::debug_fn(sys::get_type_desc::<T>(), transmute(&x));
     }
 }
 
 pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
     transmute(
-        rustrt::debug_ptrcast(sys::get_type_desc::<T>(),
-                              transmute(x)))
+        rustrt::debug_ptrcast(sys::get_type_desc::<T>(), transmute(x)))
 }
 
 /// Triggers a debugger breakpoint
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index aa1903e4a21..bf1b9dc0cda 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -110,18 +110,18 @@ enum IpGetAddrErr {
  * object in the case of failure
 */
 pub fn get_addr(node: &str, iotask: &iotask)
-    -> result::Result<~[IpAddr], IpGetAddrErr> {
+                -> result::Result<~[IpAddr], IpGetAddrErr> {
     let (output_po, output_ch) = stream();
     let mut output_ch = Some(SharedChan::new(output_ch));
     do str::as_buf(node) |node_ptr, len| {
         let output_ch = output_ch.swap_unwrap();
         debug!("slice len %?", len);
         let handle = create_uv_getaddrinfo_t();
-        let handle_ptr = ptr::addr_of(&handle);
+        let handle_ptr: *uv_getaddrinfo_t = &handle;
         let handle_data = GetAddrData {
             output_ch: output_ch.clone()
         };
-        let handle_data_ptr = ptr::addr_of(&handle_data);
+        let handle_data_ptr: *GetAddrData = &handle_data;
         do interact(iotask) |loop_ptr| {
             unsafe {
                 let result = uv_getaddrinfo(
@@ -189,7 +189,8 @@ pub mod v4 {
     impl AsUnsafeU32 for Ipv4Rep {
         // this is pretty dastardly, i know
         unsafe fn as_u32(&self) -> u32 {
-            *((ptr::addr_of(self)) as *u32)
+            let this: &mut u32 = transmute(self);
+            *this
         }
     }
     pub fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
@@ -297,7 +298,8 @@ struct GetAddrData {
     output_ch: SharedChan<result::Result<~[IpAddr],IpGetAddrErr>>
 }
 
-extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
+extern fn get_addr_cb(handle: *uv_getaddrinfo_t,
+                      status: libc::c_int,
                       res: *addrinfo) {
     unsafe {
         debug!("in get_addr_cb");
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index ee109047cb1..764152d6812 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -156,7 +156,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
             result_ch: result_ch,
             closed_signal_ch: closed_signal_ch
         };
-        let conn_data_ptr = ptr::addr_of(&conn_data);
+        let conn_data_ptr: *ConnectReqData = &conn_data;
         let (reader_po, reader_ch) = stream::<Result<~[u8], TcpErrData>>();
         let reader_ch = SharedChan::new(reader_ch);
         let stream_handle_ptr = malloc_uv_tcp_t();
@@ -173,7 +173,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
             },
             iotask: iotask.clone()
         };
-        let socket_data_ptr = ptr::addr_of(&(*socket_data));
+        let socket_data_ptr: *TcpSocketData = &*socket_data;
         // get an unsafe representation of our stream_handle_ptr that
         // we can send into the interact cb to be handled in libuv..
         debug!("stream_handle_ptr outside interact %?",
@@ -187,8 +187,8 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                     0i32 => {
                         debug!("tcp_init successful");
                         debug!("dealing w/ ipv4 connection..");
-                        let connect_req_ptr =
-                            ptr::addr_of(&((*socket_data_ptr).connect_req));
+                        let connect_req_ptr: *uv::ll::uv_connect_t =
+                            &(*socket_data_ptr).connect_req;
                         let addr_str = ip::format_addr(&input_ip);
                         let connect_result = match input_ip {
                             ip::Ipv4(ref addr) => {
@@ -205,7 +205,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                                 uv::ll::tcp_connect(
                                     connect_req_ptr,
                                     stream_handle_ptr,
-                                    ptr::addr_of(&in_addr),
+                                    &in_addr,
                                     tcp_connect_on_connect_cb)
                             }
                             ip::Ipv6(ref addr) => {
@@ -215,7 +215,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                                 uv::ll::tcp_connect6(
                                     connect_req_ptr,
                                     stream_handle_ptr,
-                                    ptr::addr_of(&in_addr),
+                                    &in_addr,
                                     tcp_connect_on_connect_cb)
                             }
                         };
@@ -303,9 +303,8 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
  * `TcpErrData` value as the `Err` variant
  */
 pub fn write(sock: &TcpSocket, raw_write_data: ~[u8])
-    -> result::Result<(), TcpErrData>
-{
-    let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
+             -> result::Result<(), TcpErrData> {
+    let socket_data_ptr: *TcpSocketData = &*sock.socket_data;
     write_common_impl(socket_data_ptr, raw_write_data)
 }
 
@@ -343,7 +342,7 @@ pub fn write(sock: &TcpSocket, raw_write_data: ~[u8])
 pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
     -> future::Future<result::Result<(), TcpErrData>>
 {
-    let socket_data_ptr = ptr::addr_of(&(*(sock.socket_data)));
+    let socket_data_ptr: *TcpSocketData = &*sock.socket_data;
     do future_spawn {
         let data_copy = copy(raw_write_data);
         write_common_impl(socket_data_ptr, data_copy)
@@ -366,9 +365,10 @@ pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
  * `TcpErrData` record
  */
 pub fn read_start(sock: &TcpSocket)
-    -> result::Result<@Port<
-        result::Result<~[u8], TcpErrData>>, TcpErrData> {
-    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
+                  -> result::Result<@Port<result::Result<~[u8],
+                                                         TcpErrData>>,
+                                    TcpErrData> {
+    let socket_data: *TcpSocketData = &*sock.socket_data;
     read_start_common_impl(socket_data)
 }
 
@@ -380,7 +380,7 @@ pub fn read_start(sock: &TcpSocket)
  * * `sock` - a `net::tcp::TcpSocket` that you wish to stop reading on
  */
 pub fn read_stop(sock: &TcpSocket) -> result::Result<(), TcpErrData> {
-    let socket_data = ptr::addr_of(&(*sock.socket_data));
+    let socket_data: *TcpSocketData = &*sock.socket_data;
     read_stop_common_impl(socket_data)
 }
 
@@ -400,8 +400,8 @@ pub fn read_stop(sock: &TcpSocket) -> result::Result<(), TcpErrData> {
  * read attempt. Pass `0u` to wait indefinitely
  */
 pub fn read(sock: &TcpSocket, timeout_msecs: uint)
-    -> result::Result<~[u8],TcpErrData> {
-    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
+            -> result::Result<~[u8],TcpErrData> {
+    let socket_data: *TcpSocketData = &*sock.socket_data;
     read_common_impl(socket_data, timeout_msecs)
 }
 
@@ -435,8 +435,8 @@ pub fn read(sock: &TcpSocket, timeout_msecs: uint)
  * read attempt. Pass `0u` to wait indefinitely
  */
 fn read_future(sock: &TcpSocket, timeout_msecs: uint)
-    -> future::Future<result::Result<~[u8],TcpErrData>> {
-    let socket_data = ptr::addr_of(&(*(sock.socket_data)));
+               -> future::Future<result::Result<~[u8],TcpErrData>> {
+    let socket_data: *TcpSocketData = &*sock.socket_data;
     do future_spawn {
         read_common_impl(socket_data, timeout_msecs)
     }
@@ -534,8 +534,8 @@ pub fn accept(new_conn: TcpNewConnection)
                     ipv6: (*server_data_ptr).ipv6,
                     iotask : iotask.clone()
                 };
-                let client_socket_data_ptr = ptr::addr_of(
-                    &(*client_socket_data));
+                let client_socket_data_ptr: *TcpSocketData =
+                    &*client_socket_data;
                 let client_stream_handle_ptr =
                     (*client_socket_data_ptr).stream_handle_ptr;
 
@@ -661,7 +661,7 @@ fn listen_common(host_ip: ip::IpAddr,
     let (kill_po, kill_ch) = stream::<Option<TcpErrData>>();
     let kill_ch = SharedChan::new(kill_ch);
     let server_stream = uv::ll::tcp_t();
-    let server_stream_ptr = ptr::addr_of(&server_stream);
+    let server_stream_ptr: *uv::ll::uv_tcp_t = &server_stream;
     let server_data: TcpListenFcData = TcpListenFcData {
         server_stream_ptr: server_stream_ptr,
         stream_closed_ch: stream_closed_ch,
@@ -674,7 +674,7 @@ fn listen_common(host_ip: ip::IpAddr,
         },
         mut active: true
     };
-    let server_data_ptr = ptr::addr_of(&server_data);
+    let server_data_ptr: *TcpListenFcData = &server_data;
 
     let (setup_po, setup_ch) = stream();
 
@@ -699,16 +699,14 @@ fn listen_common(host_ip: ip::IpAddr,
                             let in_addr = uv::ll::ip4_addr(
                                 addr_str,
                                 port as int);
-                            uv::ll::tcp_bind(server_stream_ptr,
-                                             ptr::addr_of(&in_addr))
+                            uv::ll::tcp_bind(server_stream_ptr, &in_addr)
                         }
                         ip::Ipv6(ref addr) => {
                             debug!("addr: %?", addr);
                             let in_addr = uv::ll::ip6_addr(
                                 addr_str,
                                 port as int);
-                            uv::ll::tcp_bind6(server_stream_ptr,
-                                              ptr::addr_of(&in_addr))
+                            uv::ll::tcp_bind6(server_stream_ptr, &in_addr)
                         }
                     };
                     match bind_result {
@@ -856,12 +854,12 @@ pub impl TcpSocket {
             if self.socket_data.ipv6 {
                 let addr = uv::ll::ip6_addr("", 0);
                 uv::ll::tcp_getpeername6(self.socket_data.stream_handle_ptr,
-                                         ptr::addr_of(&addr));
+                                         &addr);
                 ip::Ipv6(addr)
             } else {
                 let addr = uv::ll::ip4_addr("", 0);
                 uv::ll::tcp_getpeername(self.socket_data.stream_handle_ptr,
-                                        ptr::addr_of(&addr));
+                                        &addr);
                 ip::Ipv4(addr)
             }
         }
@@ -973,13 +971,12 @@ impl io::Reader for TcpSocketBuf {
 impl io::Writer for TcpSocketBuf {
     pub fn write(&self, data: &const [u8]) {
         unsafe {
-            let socket_data_ptr =
-                ptr::addr_of(&(*((*(self.data)).sock).socket_data));
+            let socket_data_ptr: *TcpSocketData =
+                &(*((*(self.data)).sock).socket_data);
             let w_result = write_common_impl(socket_data_ptr,
-                                            vec::slice(data,
-                                                       0,
-                                                       vec::len(data)
-                                                      ).to_vec());
+                                             vec::slice(data,
+                                                        0,
+                                                        data.len()).to_vec());
             if w_result.is_err() {
                 let err_data = w_result.get_err();
                 debug!(
@@ -1012,7 +1009,7 @@ fn tear_down_socket_data(socket_data: @TcpSocketData) {
         let close_data = TcpSocketCloseData {
             closed_ch: closed_ch
         };
-        let close_data_ptr = ptr::addr_of(&close_data);
+        let close_data_ptr: *TcpSocketCloseData = &close_data;
         let stream_handle_ptr = (*socket_data).stream_handle_ptr;
         do iotask::interact(&(*socket_data).iotask) |loop_ptr| {
             unsafe {
@@ -1150,19 +1147,21 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData,
                      raw_write_data: ~[u8])
     -> result::Result<(), TcpErrData> {
     unsafe {
-        let write_req_ptr = ptr::addr_of(&((*socket_data_ptr).write_req));
+        let write_req_ptr: *uv::ll::uv_write_t =
+            &(*socket_data_ptr).write_req;
         let stream_handle_ptr =
             (*socket_data_ptr).stream_handle_ptr;
-        let write_buf_vec =  ~[ uv::ll::buf_init(
-            vec::raw::to_ptr(raw_write_data),
-            vec::len(raw_write_data)) ];
-        let write_buf_vec_ptr = ptr::addr_of(&write_buf_vec);
+        let write_buf_vec = ~[
+            uv::ll::buf_init(vec::raw::to_ptr(raw_write_data),
+                             raw_write_data.len())
+        ];
+        let write_buf_vec_ptr: *~[uv::ll::uv_buf_t] = &write_buf_vec;
         let (result_po, result_ch) = stream::<TcpWriteResult>();
         let result_ch = SharedChan::new(result_ch);
         let write_data = WriteReqData {
             result_ch: result_ch
         };
-        let write_data_ptr = ptr::addr_of(&write_data);
+        let write_data_ptr: *WriteReqData = &write_data;
         do iotask::interact(&(*socket_data_ptr).iotask) |loop_ptr| {
             unsafe {
                 debug!("in interact cb for tcp::write %?",
diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs
index 60f25c2a270..6f408823410 100644
--- a/src/libstd/priority_queue.rs
+++ b/src/libstd/priority_queue.rs
@@ -151,7 +151,7 @@ pub impl <T:Ord> PriorityQueue<T> {
 
     priv fn siftup(&mut self, start: uint, mut pos: uint) {
         unsafe {
-            let new = *addr_of(&self.data[pos]);
+            let new = *ptr::to_unsafe_ptr(&self.data[pos]);
 
             while pos > start {
                 let parent = (pos - 1) >> 1;
@@ -171,7 +171,7 @@ pub impl <T:Ord> PriorityQueue<T> {
     priv fn siftdown_range(&mut self, mut pos: uint, end: uint) {
         unsafe {
             let start = pos;
-            let new = *addr_of(&self.data[pos]);
+            let new = *ptr::to_unsafe_ptr(&self.data[pos]);
 
             let mut child = 2 * pos + 1;
             while child < end {
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 58e5352890f..21a6153380c 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -828,7 +828,7 @@ mod tests {
         let m = ~Mutex();
         let m2 = m.clone();
         let mut sharedstate = ~0;
-        let ptr = ptr::addr_of(&(*sharedstate));
+        let ptr: *int = &*sharedstate;
         do task::spawn || {
             let sharedstate: &mut int =
                 unsafe { cast::transmute(ptr) };
@@ -1106,7 +1106,7 @@ mod tests {
         let (p,c) = comm::stream();
         let x2 = (*x).clone();
         let mut sharedstate = ~0;
-        let ptr = ptr::addr_of(&(*sharedstate));
+        let ptr: *int = &*sharedstate;
         do task::spawn || {
             let sharedstate: &mut int =
                 unsafe { cast::transmute(ptr) };
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 69e01d4e4db..b19b2f2889e 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -42,7 +42,7 @@ pub fn delayed_send<T:Owned>(iotask: &IoTask,
     let (timer_done_po, timer_done_ch) = stream::<()>();
     let timer_done_ch = SharedChan::new(timer_done_ch);
     let timer = uv::ll::timer_t();
-    let timer_ptr = ptr::addr_of(&timer);
+    let timer_ptr: *uv::ll::uv_timer_t = &timer;
     do iotask::interact(iotask) |loop_ptr| {
         unsafe {
             let init_result = uv::ll::timer_init(loop_ptr, timer_ptr);
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 2ab5ce8698c..e49cee434f8 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -162,7 +162,7 @@ mod test {
             debug!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
                             exit_ch_ptr);
             let timer_handle = ll::timer_t();
-            let timer_ptr = ptr::addr_of(&timer_handle);
+            let timer_ptr: *ll::uv_timer_t = &timer_handle;
             do iotask::interact(iotask) |loop_ptr| {
                 unsafe {
                     debug!(~"user code inside interact loop!!!");
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 309ae32dc59..e19010e8552 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -17,10 +17,9 @@
 
 use ll = uv_ll;
 
+use core::comm::{stream, Port, Chan, SharedChan};
 use core::libc::c_void;
 use core::libc;
-use core::comm::{stream, Port, Chan, SharedChan};
-use core::ptr::addr_of;
 
 /// Used to abstract-away direct interaction with a libuv loop.
 pub struct IoTask {
@@ -106,7 +105,7 @@ fn run_loop(iotask_ch: &Chan<IoTask>) {
         // set up the special async handle we'll use to allow multi-task
         // communication with this loop
         let async = ll::async_t();
-        let async_handle = addr_of(&async);
+        let async_handle: *ll::uv_async_t = &async;
 
         // associate the async handle with the loop
         ll::async_init(loop_ptr, async_handle, wake_up_cb);
@@ -118,11 +117,11 @@ fn run_loop(iotask_ch: &Chan<IoTask>) {
             async_handle: async_handle,
             msg_po: msg_po
         };
-        ll::set_data_for_uv_handle(async_handle, addr_of(&data));
+        ll::set_data_for_uv_handle(async_handle, &data);
 
         // Send out a handle through which folks can talk to us
         // while we dwell in the I/O loop
-        let iotask = IoTask{
+        let iotask = IoTask {
             async_handle: async_handle,
             op_chan: SharedChan::new(msg_ch)
         };
@@ -223,7 +222,7 @@ struct AhData {
 #[cfg(test)]
 fn impl_uv_iotask_async(iotask: &IoTask) {
     let async_handle = ll::async_t();
-    let ah_ptr = ptr::addr_of(&async_handle);
+    let ah_ptr: *ll::uv_async_t = &async_handle;
     let (exit_po, exit_ch) = stream::<()>();
     let ah_data = AhData {
         iotask: iotask.clone(),
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index fb40596b888..8e5b3274bbb 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1021,19 +1021,17 @@ pub unsafe fn async_send(async_handle: *uv_async_t) {
 }
 pub unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
     let out_buf = uv_buf_t { base: ptr::null(), len: 0 as libc::size_t };
-    let out_buf_ptr = ptr::addr_of(&out_buf);
+    let out_buf_ptr: *uv_buf_t = &out_buf;
     rustrt::rust_uv_buf_init(out_buf_ptr, input, len as size_t);
     return out_buf;
 }
-pub unsafe fn ip4_addr(ip: &str, port: int)
--> sockaddr_in {
+pub unsafe fn ip4_addr(ip: &str, port: int) -> sockaddr_in {
     do str::as_c_str(ip) |ip_buf| {
         rustrt::rust_uv_ip4_addr(ip_buf as *u8,
                                  port as libc::c_int)
     }
 }
-pub unsafe fn ip6_addr(ip: &str, port: int)
--> sockaddr_in6 {
+pub unsafe fn ip6_addr(ip: &str, port: int) -> sockaddr_in6 {
     do str::as_c_str(ip) |ip_buf| {
         rustrt::rust_uv_ip6_addr(ip_buf as *u8,
                                  port as libc::c_int)
@@ -1183,7 +1181,7 @@ pub unsafe fn free_base_of_buf(buf: uv_buf_t) {
 
 pub unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
     let err = last_error(uv_loop);
-    let err_ptr = ptr::addr_of(&err);
+    let err_ptr: *uv_err_t = &err;
     let err_name = str::raw::from_c_str(err_name(err_ptr));
     let err_msg = str::raw::from_c_str(strerror(err_ptr));
     return fmt!("LIBUV ERROR: name: %s msg: %s",
@@ -1192,7 +1190,7 @@ pub unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
 
 pub unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
     let err = last_error(uv_loop);
-    let err_ptr = ptr::addr_of(&err);
+    let err_ptr: *uv_err_t = &err;
     let err_name = str::raw::from_c_str(err_name(err_ptr));
     let err_msg = str::raw::from_c_str(strerror(err_ptr));
     uv_err_data { err_name: err_name, err_msg: err_msg }
@@ -1347,9 +1345,9 @@ mod test {
         unsafe {
             let test_loop = loop_new();
             let tcp_handle = tcp_t();
-            let tcp_handle_ptr = ptr::addr_of(&tcp_handle);
+            let tcp_handle_ptr: *uv_tcp_t = &tcp_handle;
             let connect_handle = connect_t();
-            let connect_req_ptr = ptr::addr_of(&connect_handle);
+            let connect_req_ptr: *uv_connect_t = &connect_handle;
 
             // this is the persistent payload of data that we
             // need to pass around to get this example to work.
@@ -1365,43 +1363,42 @@ mod test {
             // this is the enclosing record, we'll pass a ptr to
             // this to C..
             let write_handle = write_t();
-            let write_handle_ptr = ptr::addr_of(&write_handle);
+            let write_handle_ptr: *uv_write_t = &write_handle;
             debug!("tcp req: tcp stream: %d write_handle: %d",
                              tcp_handle_ptr as int,
                              write_handle_ptr as int);
             let client_data = request_wrapper {
                 write_req: write_handle_ptr,
-                req_buf: ptr::addr_of(&req_msg),
+                req_buf: &req_msg,
                 read_chan: client_chan
             };
 
-            let tcp_init_result = tcp_init(
-                test_loop as *libc::c_void, tcp_handle_ptr);
-            if (tcp_init_result == 0i32) {
+            let tcp_init_result = tcp_init(test_loop as *libc::c_void,
+                                           tcp_handle_ptr);
+            if (tcp_init_result == 0) {
                 debug!(~"sucessful tcp_init_result");
 
                 debug!(~"building addr...");
                 let addr = ip4_addr(ip, port);
                 // FIXME ref #2064
-                let addr_ptr = ptr::addr_of(&addr);
+                let addr_ptr: *sockaddr_in = &addr;
                 debug!("after build addr in rust. port: %u",
-                                 addr.sin_port as uint);
+                       addr.sin_port as uint);
 
                 // this should set up the connection request..
                 debug!("b4 call tcp_connect connect cb: %u ",
-                                on_connect_cb as uint);
-                let tcp_connect_result = tcp_connect(
-                    connect_req_ptr, tcp_handle_ptr,
-                    addr_ptr, on_connect_cb);
-                if (tcp_connect_result == 0i32) {
+                       on_connect_cb as uint);
+                let tcp_connect_result = tcp_connect(connect_req_ptr,
+                                                     tcp_handle_ptr,
+                                                     addr_ptr,
+                                                     on_connect_cb);
+                if (tcp_connect_result == 0) {
                     // not set the data on the connect_req
                     // until its initialized
-                    set_data_for_req(
-                        connect_req_ptr as *libc::c_void,
-                        ptr::addr_of(&client_data) as *libc::c_void);
-                    set_data_for_uv_handle(
-                        tcp_handle_ptr as *libc::c_void,
-                        ptr::addr_of(&client_data) as *libc::c_void);
+                    set_data_for_req(connect_req_ptr as *libc::c_void,
+                                     transmute(&client_data));
+                    set_data_for_uv_handle(tcp_handle_ptr as *libc::c_void,
+                                           transmute(&client_data));
                     debug!(~"before run tcp req loop");
                     run(test_loop);
                     debug!(~"after run tcp req loop");
@@ -1607,37 +1604,37 @@ mod test {
         unsafe {
             let test_loop = loop_new();
             let tcp_server = tcp_t();
-            let tcp_server_ptr = ptr::addr_of(&tcp_server);
+            let tcp_server_ptr: *uv_tcp_t = &tcp_server;
 
             let tcp_client = tcp_t();
-            let tcp_client_ptr = ptr::addr_of(&tcp_client);
+            let tcp_client_ptr: *uv_tcp_t = &tcp_client;
 
             let server_write_req = write_t();
-            let server_write_req_ptr = ptr::addr_of(&server_write_req);
+            let server_write_req_ptr: *uv_write_t = &server_write_req;
 
             let resp_str_bytes = str::to_bytes(server_resp_msg);
             let resp_msg_ptr: *u8 = vec::raw::to_ptr(resp_str_bytes);
             debug!("resp_msg ptr: %u", resp_msg_ptr as uint);
             let resp_msg = ~[
-                buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
+                buf_init(resp_msg_ptr, resp_str_bytes.len())
             ];
 
             let continue_async_handle = async_t();
-            let continue_async_handle_ptr =
-                ptr::addr_of(&continue_async_handle);
+            let continue_async_handle_ptr: *uv_async_t =
+                &continue_async_handle;
             let async_data =
                 async_handle_data { continue_chan: continue_chan };
-            let async_data_ptr = ptr::addr_of(&async_data);
+            let async_data_ptr: *async_handle_data = &async_data;
 
             let server_data = tcp_server_data {
                 client: tcp_client_ptr,
                 server: tcp_server_ptr,
                 server_kill_msg: kill_server_msg,
-                server_resp_buf: ptr::addr_of(&resp_msg),
+                server_resp_buf: &resp_msg,
                 server_chan: server_chan,
                 server_write_req: server_write_req_ptr
             };
-            let server_data_ptr = ptr::addr_of(&server_data);
+            let server_data_ptr: *tcp_server_data = &server_data;
             set_data_for_uv_handle(tcp_server_ptr as *libc::c_void,
                                            server_data_ptr as *libc::c_void);
 
@@ -1647,11 +1644,10 @@ mod test {
             if (tcp_init_result == 0i32) {
                 let server_addr = ip4_addr(server_ip, server_port);
                 // FIXME ref #2064
-                let server_addr_ptr = ptr::addr_of(&server_addr);
+                let server_addr_ptr: *sockaddr_in = &server_addr;
 
                 // uv_tcp_bind()
-                let bind_result = tcp_bind(tcp_server_ptr,
-                                                   server_addr_ptr);
+                let bind_result = tcp_bind(tcp_server_ptr, server_addr_ptr);
                 if (bind_result == 0i32) {
                     debug!(~"successful uv_tcp_bind, listening");