Add a demoded version of ptr::addr_of

Currently, the new version is ptr::p2::addr_of and the old one is
ptr::addr_of. This is kind of cheesy, but I need a snapshot before I
can ditch the old version, since the pipe compiler generates calls to
addr_of.

core is converted over to use the new version, std is not.

Author: catamorphism

src/libcore/at_vec.rs

@@ -5,7 +5,7 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
-use ptr::addr_of;
+use ptr::p2::addr_of;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
@@ -29,7 +29,7 @@ extern mod rusti {
 pub pure fn capacity<T>(v: @[const T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr =
-            ::cast::reinterpret_cast(&addr_of(v));
+            ::cast::reinterpret_cast(&addr_of(&v));
         (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
@@ -161,7 +161,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: @[const T], new_len: uint) {
-        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -182,7 +182,7 @@ pub mod raw {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
-        let p = ptr::addr_of((**repr).unboxed.data);
+        let p = addr_of(&((**repr).unboxed.data));
         let p = ptr::offset(p, fill) as *mut T;
         rusti::move_val_init(*p, move initval);
     }

src/libcore/box.rs

@@ -24,7 +24,7 @@ pub mod raw {
 
 pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     //! Determine if two shared boxes point to the same object
-    unsafe { ptr::addr_of(*a) == ptr::addr_of(*b) }
+    unsafe { ptr::p2::addr_of(&(*a)) == ptr::p2::addr_of(&(*b)) }
 }
 
 impl<T:Eq> @const T : Eq {

src/libcore/comm.rs

@@ -38,8 +38,7 @@ will once again be the preferred module for intertask communication.
 
 use either::Either;
 use libc::size_t;
-
-
+// After snapshot, change p2::addr_of => addr_of
 
 /**
  * A communication endpoint that can receive messages
@@ -104,7 +103,7 @@ struct PortPtr<T:Send> {
         // Once the port is detached it's guaranteed not to receive further
         // messages
         let yield = 0;
-        let yieldp = ptr::addr_of(yield);
+        let yieldp = ptr::p2::addr_of(&yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
         if yield != 0 {
             // Need to wait for the port to be detached
@@ -177,7 +176,7 @@ pub fn Chan<T: Send>(p: Port<T>) -> Chan<T> {
  */
 pub fn send<T: Send>(ch: Chan<T>, +data: T) {
     let Chan_(p) = ch;
-    let data_ptr = ptr::addr_of(data) as *();
+    let data_ptr = ptr::p2::addr_of(&data) as *();
     let res = rustrt::rust_port_id_send(p, data_ptr);
     if res != 0 unsafe {
         // Data sent successfully
@@ -207,10 +206,10 @@ fn peek_chan<T: Send>(ch: comm::Chan<T>) -> bool {
 /// Receive on a raw port pointer
 fn recv_<T: Send>(p: *rust_port) -> T {
     let yield = 0;
-    let yieldp = ptr::addr_of(yield);
+    let yieldp = ptr::p2::addr_of(&yield);
     let mut res;
     res = rusti::init::<T>();
-    rustrt::port_recv(ptr::addr_of(res) as *uint, p, yieldp);
+    rustrt::port_recv(ptr::p2::addr_of(&res) as *uint, p, yieldp);
 
     if yield != 0 {
         // Data isn't available yet, so res has not been initialized.
@@ -234,12 +233,12 @@ fn peek_(p: *rust_port) -> bool {
 pub fn select2<A: Send, B: Send>(p_a: Port<A>, p_b: Port<B>)
     -> Either<A, B> {
     let ports = ~[(**p_a).po, (**p_b).po];
-    let yield = 0, yieldp = ptr::addr_of(yield);
+    let yield = 0, yieldp = ptr::p2::addr_of(&yield);
 
     let mut resport: *rust_port;
     resport = rusti::init::<*rust_port>();
     do vec::as_imm_buf(ports) |ports, n_ports| {
-        rustrt::rust_port_select(ptr::addr_of(resport), ports,
+        rustrt::rust_port_select(ptr::p2::addr_of(&resport), ports,
                                  n_ports as size_t, yieldp);
     }
 

src/libcore/core.rc

@@ -39,6 +39,7 @@ Implicitly, all crates behave as if they included the following prologue:
 #[legacy_modes];
 #[legacy_exports];
 
+#[warn(deprecated_mode)];
 #[warn(deprecated_pattern)];
 
 #[warn(vecs_implicitly_copyable)];

src/libcore/gc.rs

@@ -316,7 +316,7 @@ pub fn cleanup_stack_for_failure() {
         // own stack roots on the stack anyway.
         let sentinel_box = ~0;
         let sentinel: **Word = if expect_sentinel() {
-            cast::reinterpret_cast(&ptr::addr_of(sentinel_box))
+            cast::reinterpret_cast(&ptr::p2::addr_of(&sentinel_box))
         } else {
             ptr::null()
         };

src/libcore/io.rs

@@ -889,8 +889,8 @@ mod tests {
     #[test]
     fn test_readchars_empty() {
         do io::with_str_reader(~"") |inp| {
-            let res : ~[char] = inp.read_chars(128u);
-            assert(vec::len(res) == 0u);
+            let res : ~[char] = inp.read_chars(128);
+            assert(vec::len(res) == 0);
         }
     }
 
@@ -903,7 +903,7 @@ mod tests {
             104, 101, 108, 108, 111,
             29983, 38152, 30340, 27748,
             21273, 20999, 32905, 27748];
-        fn check_read_ln(len : uint, s: ~str, ivals: ~[int]) {
+        fn check_read_ln(len : uint, s: &str, ivals: &[int]) {
             do io::with_str_reader(s) |inp| {
                 let res : ~[char] = inp.read_chars(len);
                 if (len <= vec::len(ivals)) {
@@ -913,13 +913,13 @@ mod tests {
                        vec::map(res, |x| *x as int));
             }
         }
-        let mut i = 0u;
-        while i < 8u {
+        let mut i = 0;
+        while i < 8 {
             check_read_ln(i, wide_test, ivals);
-            i += 1u;
+            i += 1;
         }
         // check a long read for good measure
-        check_read_ln(128u, wide_test, ivals);
+        check_read_ln(128, wide_test, ivals);
     }
 
     #[test]

src/libcore/iter-trait.rs

@@ -19,13 +19,13 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
         iter::foldl(&self, move b0, blk)
     }
-    pure fn position(f: fn(A) -> bool) -> Option<uint> {
-        iter::position(self, f)
+    pure fn position(f: fn(&A) -> bool) -> Option<uint> {
+        iter::position(&self, f)
     }
 }
 
 impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
-    pure fn contains(x: &A) -> bool { iter::contains(self, x) }
+    pure fn contains(x: &A) -> bool { iter::contains(&self, x) }
     pure fn count(x: &A) -> uint { iter::count(&self, x) }
 }
 
@@ -43,7 +43,7 @@ impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
         iter::flat_map_to_vec(&self, op)
     }
 
-    pure fn find(p: fn(A) -> bool) -> Option<A> { iter::find(self, p) }
+    pure fn find(p: fn(+a: A) -> bool) -> Option<A> { iter::find(&self, p) }
 }
 
 impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {

src/libcore/iter.rs

@@ -19,7 +19,7 @@ trait ExtendedIter<A> {
     pure fn all(blk: fn(&A) -> bool) -> bool;
     pure fn any(blk: fn(&A) -> bool) -> bool;
     pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B;
-    pure fn position(f: fn(A) -> bool) -> Option<uint>;
+    pure fn position(f: fn(&A) -> bool) -> Option<uint>;
 }
 
 trait EqIter<A:Eq> {
@@ -38,7 +38,7 @@ trait CopyableIter<A:Copy> {
     pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
     pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
     pure fn to_vec() -> ~[A];
-    pure fn find(p: fn(A) -> bool) -> Option<A>;
+    pure fn find(p: fn(+a: A) -> bool) -> Option<A>;
 }
 
 trait CopyableOrderedIter<A:Copy Ord> {
@@ -131,7 +131,7 @@ pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] {
     foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy (*r), ~[*a]))
 }
 
-pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> bool {
+pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool {
     for self.each |a| {
         if *a == *x { return true; }
     }
@@ -148,12 +148,12 @@ pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
     }
 }
 
-pure fn position<A,IA:BaseIter<A>>(self: IA, f: fn(A) -> bool)
+pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
     -> Option<uint>
 {
     let mut i = 0;
     for self.each |a| {
-        if f(*a) { return Some(i); }
+        if f(a) { return Some(i); }
         i += 1;
     }
     return None;
@@ -164,10 +164,10 @@ pure fn position<A,IA:BaseIter<A>>(self: IA, f: fn(A) -> bool)
 // it would have to be implemented with foldr, which is too inefficient.
 
 pure fn repeat(times: uint, blk: fn() -> bool) {
-    let mut i = 0u;
+    let mut i = 0;
     while i < times {
         if !blk() { break }
-        i += 1u;
+        i += 1;
     }
 }
 
@@ -199,8 +199,8 @@ pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
     }
 }
 
-pure fn find<A: Copy,IA:BaseIter<A>>(self: IA,
-                                     p: fn(A) -> bool) -> Option<A> {
+pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
+                                     p: fn(+a: A) -> bool) -> Option<A> {
     for self.each |i| {
         if p(*i) { return Some(*i) }
     }

src/libcore/option.rs

@@ -252,20 +252,20 @@ impl<T: Eq> Option<T> : Eq {
 #[test]
 fn test_unwrap_ptr() {
     let x = ~0;
-    let addr_x = ptr::addr_of(*x);
+    let addr_x = ptr::p2::addr_of(&(*x));
     let opt = Some(x);
     let y = unwrap(opt);
-    let addr_y = ptr::addr_of(*y);
+    let addr_y = ptr::p2::addr_of(&(*y));
     assert addr_x == addr_y;
 }
 
 #[test]
 fn test_unwrap_str() {
     let x = ~"test";
-    let addr_x = str::as_buf(x, |buf, _len| ptr::addr_of(buf));
+    let addr_x = str::as_buf(x, |buf, _len| ptr::p2::addr_of(&buf));
     let opt = Some(x);
     let y = unwrap(opt);
-    let addr_y = str::as_buf(y, |buf, _len| ptr::addr_of(buf));
+    let addr_y = str::as_buf(y, |buf, _len| ptr::p2::addr_of(&buf));
     assert addr_x == addr_y;
 }
 

src/libcore/os.rs

@@ -303,7 +303,7 @@ pub fn waitpid(pid: pid_t) -> c_int {
     use libc::funcs::posix01::wait::*;
     let status = 0 as c_int;
 
-    assert (waitpid(pid, ptr::mut_addr_of(status),
+    assert (waitpid(pid, ptr::mut_addr_of(&status),
                     0 as c_int) != (-1 as c_int));
     return status;
 }
@@ -313,7 +313,7 @@ pub fn waitpid(pid: pid_t) -> c_int {
 pub fn pipe() -> {in: c_int, out: c_int} {
     let fds = {mut in: 0 as c_int,
                mut out: 0 as c_int };
-    assert (libc::pipe(ptr::mut_addr_of(fds.in)) == (0 as c_int));
+    assert (libc::pipe(ptr::mut_addr_of(&(fds.in))) == (0 as c_int));
     return {in: fds.in, out: fds.out};
 }
 
@@ -384,7 +384,7 @@ pub fn self_exe_path() -> Option<Path> {
     #[cfg(target_os = "macos")]
     fn load_self() -> Option<~str> {
         do fill_charp_buf() |buf, sz| {
-            libc::_NSGetExecutablePath(buf, ptr::mut_addr_of(sz as u32))
+            libc::_NSGetExecutablePath(buf, ptr::mut_addr_of(&(sz as u32)))
                 == (0 as c_int)
         }
     }

src/libcore/pipes.rs

@@ -219,7 +219,7 @@ fn unibuffer<T: Send>() -> ~Buffer<Packet<T>> {
 #[doc(hidden)]
 pub fn packet<T: Send>() -> *Packet<T> {
     let b = unibuffer();
-    let p = ptr::addr_of(b.data);
+    let p = ptr::p2::addr_of(&(b.data));
     // We'll take over memory management from here.
     unsafe { forget(move b) }
     p
@@ -359,7 +359,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
-    assert ptr::addr_of(p.header) == header;
+    assert ptr::p2::addr_of(&(p.header)) == header;
     assert p.payload.is_none();
     p.payload <- Some(move payload);
     let old_state = swap_state_rel(&mut p.header.state, Full);
@@ -377,7 +377,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
                 rustrt::task_signal_event(
-                    old_task, ptr::addr_of(p.header) as *libc::c_void);
+                    old_task, ptr::p2::addr_of(&(p.header)) as *libc::c_void);
                 rustrt::rust_task_deref(old_task);
             }
 
@@ -529,7 +529,7 @@ fn sender_terminate<T: Send>(p: *Packet<T>) {
         if !old_task.is_null() {
             rustrt::task_signal_event(
                 old_task,
-                ptr::addr_of(p.header) as *libc::c_void);
+                ptr::p2::addr_of(&(p.header)) as *libc::c_void);
             rustrt::rust_task_deref(old_task);
         }
         // The receiver will eventually clean up.
@@ -744,7 +744,7 @@ pub fn SendPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
         p: Some(p),
         buffer: unsafe {
             Some(BufferResource(
-                get_buffer(ptr::addr_of((*p).header))))
+                get_buffer(ptr::p2::addr_of(&((*p).header)))))
         }
     }
 }
@@ -760,7 +760,7 @@ impl<T: Send, Tbuffer: Send> SendPacketBuffered<T, Tbuffer> {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
-            let header = ptr::addr_of(packet.header);
+            let header = ptr::p2::addr_of(&(packet.header));
             //forget(packet);
             header
           },
@@ -815,7 +815,7 @@ impl<T: Send, Tbuffer: Send> RecvPacketBuffered<T, Tbuffer> : Selectable {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
-            let header = ptr::addr_of(packet.header);
+            let header = ptr::p2::addr_of(&(packet.header));
             //forget(packet);
             header
           },
@@ -838,7 +838,7 @@ pub fn RecvPacketBuffered<T: Send, Tbuffer: Send>(p: *Packet<T>)
         p: Some(p),
         buffer: unsafe {
             Some(BufferResource(
-                get_buffer(ptr::addr_of((*p).header))))
+                get_buffer(ptr::p2::addr_of(&((*p).header)))))
         }
     }
 }