syntax: Rewrite P::map and MoveMap to not use unstable ptr::read_and_drop

While this is slower than before, it's not necessarily forward
compatible with planned changes to the drop flag. Benchmarking suggests
that this does not dramatically impact the compile times of rust.

Author: erickt

src/libsyntax/fold.rs

@@ -25,7 +25,6 @@ use codemap::{respan, Span, Spanned};
 use owned_slice::OwnedSlice;
 use parse::token;
 use ptr::P;
-use std::ptr;
 use util::small_vector::SmallVector;
 
 use std::rc::Rc;
@@ -36,14 +35,8 @@ pub trait MoveMap<T> {
 }
 
 impl<T> MoveMap<T> for Vec<T> {
-    fn move_map<F>(mut self, mut f: F) -> Vec<T> where F: FnMut(T) -> T {
-        for p in &mut self {
-            unsafe {
-                // FIXME(#5016) this shouldn't need to zero to be safe.
-                ptr::write(p, f(ptr::read_and_drop(p)));
-            }
-        }
-        self
+    fn move_map<F>(self, mut f: F) -> Vec<T> where F: FnMut(T) -> T {
+        self.into_iter().map(|p| f(p)).collect()
     }
 }
 

src/libsyntax/ptr.rs

@@ -39,7 +39,6 @@
 use std::fmt::{self, Display, Debug};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
-use std::ptr;
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
@@ -66,15 +65,10 @@ impl<T: 'static> P<T> {
     }
 
     /// Transform the inner value, consuming `self` and producing a new `P<T>`.
-    pub fn map<F>(mut self, f: F) -> P<T> where
+    pub fn map<F>(self, f: F) -> P<T> where
         F: FnOnce(T) -> T,
     {
-        unsafe {
-            let p = &mut *self.ptr;
-            // FIXME(#5016) this shouldn't need to drop-fill to be safe.
-            ptr::write(p, f(ptr::read_and_drop(p)));
-        }
-        self
+        P(f(*self.ptr))
     }
 }