Fix rebase

Author: petrochenkov

src/librustc_front/fold.rs

@@ -19,7 +19,7 @@ use hir;
 use syntax::codemap::{respan, Span, Spanned};
 use syntax::ptr::P;
 use syntax::parse::token;
-use syntax::util::MoveMap;
+use syntax::util::{MoveMap, MoveFlatMap};
 
 pub trait Folder : Sized {
     // Any additions to this trait should happen in form
@@ -477,7 +477,7 @@ pub fn noop_fold_local<T: Folder>(l: P<Local>, fld: &mut T) -> P<Local> {
             pat: fld.fold_pat(pat),
             init: init.map(|e| fld.fold_expr(e)),
             span: fld.new_span(span),
-            attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs, fld)),
+            attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs.into(), fld).into()),
         }
     })
 }
@@ -1132,7 +1132,7 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span, attrs }: Expr, folder: &
             }
         },
         span: folder.new_span(span),
-        attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs, folder)),
+        attrs: attrs.map_thin_attrs(|attrs| fold_attrs(attrs.into(), folder).into()),
     }
 }
 

src/librustc_front/lowering.rs

@@ -1298,7 +1298,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                         let pat_under = pat_wild(lctx, e.span);
                         let else_expr =
                             else_opt.unwrap_or_else(
-                                || expr_tuple(lctx, e.span, hir_vec![]), None);
+                                || expr_tuple(lctx, e.span, hir_vec![], None));
                         arm(hir_vec![pat_under], else_expr)
                     };
 
@@ -1460,7 +1460,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
                         };
 
                         let into_iter = expr_path(lctx, into_iter_path, None);
-                        expr_call(lctx, e.span, into_iter, hir_vec![head])
+                        expr_call(lctx, e.span, into_iter, hir_vec![head], None)
                     };
 
                     let match_expr = expr_match(lctx,

src/libsyntax/ext/expand.rs

@@ -24,14 +24,14 @@ use ext::base::*;
 use feature_gate::{self, Features, GatedCfgAttr};
 use fold;
 use fold::*;
-use util::move_map::MoveMap;
 use parse;
 use parse::token::{fresh_mark, fresh_name, intern};
 use ptr::P;
 use util::small_vector::SmallVector;
 use visit;
 use visit::Visitor;
 use std_inject;
+use util::MoveMap;
 
 use std::collections::HashSet;
 

src/libsyntax/fold.rs

@@ -25,8 +25,7 @@ use ast_util;
 use codemap::{respan, Span, Spanned};
 use parse::token;
 use ptr::P;
-// Reexported for backward compatibility, it was defined here before
-pub use util::MoveMap;
+use util::{MoveMap, MoveFlatMap};
 use util::small_vector::SmallVector;
 
 use std::rc::Rc;

src/libsyntax/lib.rs

@@ -62,7 +62,7 @@ macro_rules! panictry {
 }
 
 pub mod util {
-    pub use self::move_map::MoveMap;
+    pub use self::move_map::{MoveMap, MoveFlatMap};
 
     pub mod interner;
     pub mod lev_distance;
@@ -72,7 +72,6 @@ pub mod util {
     #[cfg(test)]
     pub mod parser_testing;
     pub mod small_vector;
-    pub mod move_map;
 }
 
 pub mod diagnostics {

src/libsyntax/util/move_map.rs

@@ -8,21 +8,38 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use owned_slice::OwnedSlice;
-
 use std::ptr;
 
-pub trait MoveMap<T>: Sized {
-    fn move_map<F>(self, mut f: F) -> Self where F: FnMut(T) -> T {
-        self.move_flat_map(|e| Some(f(e)))
-    }
+pub trait MoveMap {
+    type Item;
+    fn move_map<F>(self, f: F) -> Self
+        where F: FnMut(Self::Item) -> Self::Item;
+}
 
+pub trait MoveFlatMap {
+    type Item;
     fn move_flat_map<F, I>(self, f: F) -> Self
-        where F: FnMut(T) -> I,
-              I: IntoIterator<Item=T>;
+        where F: FnMut(Self::Item) -> I,
+              I: IntoIterator<Item = Self::Item>;
+}
+
+impl<Container, T> MoveMap for Container
+    where for<'a> &'a mut Container: IntoIterator<Item = &'a mut T>
+{
+    type Item = T;
+    fn move_map<F>(mut self, mut f: F) -> Container 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
+    }
 }
 
-impl<T> MoveMap<T> for Vec<T> {
+impl<T> MoveFlatMap for Vec<T> {
+    type Item = T;
     fn move_flat_map<F, I>(mut self, mut f: F) -> Self
         where F: FnMut(T) -> I,
               I: IntoIterator<Item=T>
@@ -69,11 +86,13 @@ impl<T> MoveMap<T> for Vec<T> {
     }
 }
 
-impl<T> MoveMap<T> for OwnedSlice<T> {
+impl<T> MoveFlatMap for ::ptr::P<[T]> {
+    type Item = T;
     fn move_flat_map<F, I>(self, f: F) -> Self
         where F: FnMut(T) -> I,
               I: IntoIterator<Item=T>
     {
-        OwnedSlice::from_vec(self.into_vec().move_flat_map(f))
+        let v: Vec<_> = self.into();
+        v.move_flat_map(f).into()
     }
 }