Add compatibility methods for OwnedSlice + use blanket impl for MoveMap

petrochenkov · petrochenkov · commit db61fc79afb0 · 2015-12-08T21:19:06.000+03:00
+ fix rustdoc
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1559,6 +1559,7 @@ impl PrimitiveType {
 impl Clean<Type> for hir::Ty {
     fn clean(&self, cx: &DocContext) -> Type {
         use rustc_front::hir::*;
+        use std::vec;
         match self.node {
             TyPtr(ref m) => RawPointer(m.mutbl.clean(cx), box m.ty.clean(cx)),
             TyRptr(ref l, ref m) =>
@@ -1572,8 +1573,13 @@ impl Clean<Type> for hir::Ty {
                 resolve_type(cx, p.clean(cx), self.id)
             }
             TyPath(Some(ref qself), ref p) => {
-                let mut trait_path = p.clone();
-                trait_path.segments.pop();
+                let mut segments: vec::Vec<_> = p.segments.clone().into();
+                segments.pop();
+                let trait_path = hir::Path {
+                    span: p.span,
+                    global: p.global,
+                    segments: segments.into(),
+                };
                 Type::QPath {
                     name: p.segments.last().unwrap().identifier.name.clean(cx),
                     self_type: box qself.ty.clean(cx),
diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs
@@ -21,29 +21,32 @@ use syntax::ast::{Name, NodeId};
 use syntax::attr;
 use syntax::ptr::P;
 use rustc_front::hir;
+use rustc_front::hir::Vec;
+
+use std::vec;
 
 pub struct Module {
     pub name: Option<Name>,
     pub attrs: Vec<ast::Attribute>,
     pub where_outer: Span,
     pub where_inner: Span,
-    pub extern_crates: Vec<ExternCrate>,
-    pub imports: Vec<Import>,
-    pub structs: Vec<Struct>,
-    pub enums: Vec<Enum>,
-    pub fns: Vec<Function>,
-    pub mods: Vec<Module>,
+    pub extern_crates: vec::Vec<ExternCrate>,
+    pub imports: vec::Vec<Import>,
+    pub structs: vec::Vec<Struct>,
+    pub enums: vec::Vec<Enum>,
+    pub fns: vec::Vec<Function>,
+    pub mods: vec::Vec<Module>,
     pub id: NodeId,
-    pub typedefs: Vec<Typedef>,
-    pub statics: Vec<Static>,
-    pub constants: Vec<Constant>,
-    pub traits: Vec<Trait>,
+    pub typedefs: vec::Vec<Typedef>,
+    pub statics: vec::Vec<Static>,
+    pub constants: vec::Vec<Constant>,
+    pub traits: vec::Vec<Trait>,
     pub vis: hir::Visibility,
     pub stab: Option<attr::Stability>,
-    pub impls: Vec<Impl>,
-    pub def_traits: Vec<DefaultImpl>,
-    pub foreigns: Vec<hir::ForeignMod>,
-    pub macros: Vec<Macro>,
+    pub impls: vec::Vec<Impl>,
+    pub def_traits: vec::Vec<DefaultImpl>,
+    pub foreigns: vec::Vec<hir::ForeignMod>,
+    pub macros: vec::Vec<Macro>,
     pub is_crate: bool,
 }
 
@@ -57,20 +60,20 @@ impl Module {
             where_outer: syntax::codemap::DUMMY_SP,
             where_inner: syntax::codemap::DUMMY_SP,
             attrs      : Vec::new(),
-            extern_crates: Vec::new(),
-            imports    : Vec::new(),
-            structs    : Vec::new(),
-            enums      : Vec::new(),
-            fns        : Vec::new(),
-            mods       : Vec::new(),
-            typedefs   : Vec::new(),
-            statics    : Vec::new(),
-            constants  : Vec::new(),
-            traits     : Vec::new(),
-            impls      : Vec::new(),
-            def_traits : Vec::new(),
-            foreigns   : Vec::new(),
-            macros     : Vec::new(),
+            extern_crates: vec::Vec::new(),
+            imports    : vec::Vec::new(),
+            structs    : vec::Vec::new(),
+            enums      : vec::Vec::new(),
+            fns        : vec::Vec::new(),
+            mods       : vec::Vec::new(),
+            typedefs   : vec::Vec::new(),
+            statics    : vec::Vec::new(),
+            constants  : vec::Vec::new(),
+            traits     : vec::Vec::new(),
+            impls      : vec::Vec::new(),
+            def_traits : vec::Vec::new(),
+            foreigns   : vec::Vec::new(),
+            macros     : vec::Vec::new(),
             is_crate   : false,
         }
     }
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
@@ -38,7 +38,7 @@ use doctree::*;
 
 pub struct RustdocVisitor<'a, 'tcx: 'a> {
     pub module: Module,
-    pub attrs: Vec<ast::Attribute>,
+    pub attrs: hir::Vec<ast::Attribute>,
     pub cx: &'a core::DocContext<'a, 'tcx>,
     pub analysis: Option<&'a core::CrateAnalysis>,
     view_item_stack: HashSet<ast::NodeId>,
@@ -53,7 +53,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
         stack.insert(ast::CRATE_NODE_ID);
         RustdocVisitor {
             module: Module::new(None),
-            attrs: Vec::new(),
+            attrs: hir::Vec::new(),
             cx: cx,
             analysis: analysis,
             view_item_stack: stack,
@@ -146,7 +146,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
         }
     }
 
-    pub fn visit_mod_contents(&mut self, span: Span, attrs: Vec<ast::Attribute> ,
+    pub fn visit_mod_contents(&mut self, span: Span, attrs: hir::Vec<ast::Attribute> ,
                               vis: hir::Visibility, id: ast::NodeId,
                               m: &hir::Mod,
                               name: Option<ast::Name>) -> Module {
@@ -180,7 +180,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                 let mine = paths.into_iter().filter(|path| {
                     !self.resolve_id(path.node.id(), None, false, om,
                                      please_inline)
-                }).collect::<Vec<hir::PathListItem>>();
+                }).collect::<hir::Vec<_>>();
 
                 if mine.is_empty() {
                     None
diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
@@ -11,12 +11,9 @@
 use std::fmt;
 use std::iter::FromIterator;
 use std::ops::Deref;
-use std::ptr;
 use std::slice;
 use std::vec;
 
-use util::MoveMap;
-
 /// A non-growable owned slice. This is a separate type to allow the
 /// representation to change.
 #[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
@@ -28,6 +25,42 @@ impl<T> OwnedSlice<T> {
     pub fn new() -> OwnedSlice<T> {
         OwnedSlice  { data: Box::new([]) }
     }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `OwnedSlice::new` instead")]
+    pub fn empty() -> OwnedSlice<T> {
+        OwnedSlice  { data: Box::new([]) }
+    }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `OwnedSlice::from` instead")]
+    pub fn from_vec(v: Vec<T>) -> OwnedSlice<T> {
+        OwnedSlice { data: v.into_boxed_slice() }
+    }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `OwnedSlice::into` instead")]
+    pub fn into_vec(self) -> Vec<T> {
+        self.data.into_vec()
+    }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `&owned_slice[..]` instead")]
+    pub fn as_slice<'a>(&'a self) -> &'a [T] {
+        &*self.data
+    }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `OwnedSlice::into_iter` instead")]
+    pub fn move_iter(self) -> vec::IntoIter<T> {
+        self.data.into_vec().into_iter()
+    }
+
+    #[unstable(feature = "rustc_private", issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "use `iter().map(f).collect()` instead")]
+    pub fn map<U, F: FnMut(&T) -> U>(&self, f: F) -> OwnedSlice<U> {
+        self.iter().map(f).collect()
+    }
 }
 
 impl<T> Deref for OwnedSlice<T> {
@@ -86,16 +119,3 @@ impl<'a, T> IntoIterator for &'a mut OwnedSlice<T> {
         self.data.iter_mut()
     }
 }
-
-impl<T> MoveMap for OwnedSlice<T> {
-    type Item = T;
-    fn move_map<F>(mut self, mut f: F) -> OwnedSlice<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
-    }
-}
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
@@ -16,8 +16,6 @@ use std::mem;
 use std::slice;
 use std::vec;
 
-use util::MoveMap;
-
 /// A vector type optimized for cases where the size is almost always 0 or 1
 pub struct SmallVector<T> {
     repr: SmallVectorRepr<T>,
@@ -37,6 +35,14 @@ impl<T> FromIterator<T> for SmallVector<T> {
     }
 }
 
+impl<'a, T> IntoIterator for &'a mut SmallVector<T> {
+    type Item = &'a mut T;
+    type IntoIter = slice::IterMut<'a, T>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice_mut().iter_mut()
+    }
+}
+
 impl<T> Extend<T> for SmallVector<T> {
     fn extend<I: IntoIterator<Item=T>>(&mut self, iter: I) {
         for val in iter {
@@ -71,6 +77,18 @@ impl<T> SmallVector<T> {
         }
     }
 
+    pub fn as_slice_mut(&mut self) -> &mut [T] {
+        match self.repr {
+            Zero => {
+                &mut []
+            }
+            One(ref mut v) => {
+                unsafe { slice::from_raw_parts_mut(v, 1) }
+            }
+            Many(ref mut vs) => vs
+        }
+    }
+
     pub fn pop(&mut self) -> Option<T> {
         match self.repr {
             Zero => None,
@@ -195,19 +213,6 @@ impl<T> Iterator for IntoIter<T> {
     }
 }
 
-impl<T> MoveMap<T> for SmallVector<T> {
-    fn move_flat_map<F, I>(self, mut f: F) -> Self
-        where F: FnMut(T) -> I,
-              I: IntoIterator<Item=T>
-    {
-        match self.repr {
-            Zero => Self::zero(),
-            One(v) => f(v).into_iter().collect(),
-            Many(vs) => SmallVector { repr: Many(vs.move_flat_map(f)) },
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
