Align interface of OwnedSlice with Vec

Author: petrochenkov

src/librustc/middle/infer/error_reporting.rs

@@ -94,6 +94,7 @@ use syntax::owned_slice::OwnedSlice;
 use syntax::codemap::{self, Pos, Span};
 use syntax::parse::token;
 use syntax::ptr::P;
+use syntax::util::MoveMap;
 
 impl<'tcx> ty::ctxt<'tcx> {
     pub fn note_and_explain_region(&self,
@@ -1156,15 +1157,15 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                          lifetime: hir::Lifetime,
                          region_names: &HashSet<ast::Name>)
                          -> OwnedSlice<hir::TyParam> {
-        ty_params.map(|ty_param| {
-            let bounds = self.rebuild_ty_param_bounds(ty_param.bounds.clone(),
+        ty_params.move_map(|ty_param| {
+            let bounds = self.rebuild_ty_param_bounds(ty_param.bounds,
                                                       lifetime,
                                                       region_names);
             hir::TyParam {
                 name: ty_param.name,
                 id: ty_param.id,
                 bounds: bounds,
-                default: ty_param.default.clone(),
+                default: ty_param.default,
                 span: ty_param.span,
             }
         })
@@ -1175,15 +1176,15 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                                lifetime: hir::Lifetime,
                                region_names: &HashSet<ast::Name>)
                                -> OwnedSlice<hir::TyParamBound> {
-        ty_param_bounds.map(|tpb| {
+        ty_param_bounds.move_map(|tpb| {
             match tpb {
-                &hir::RegionTyParamBound(lt) => {
+                hir::RegionTyParamBound(lt) => {
                     // FIXME -- it's unclear whether I'm supposed to
                     // substitute lifetime here. I suspect we need to
                     // be passing down a map.
                     hir::RegionTyParamBound(lt)
                 }
-                &hir::TraitTyParamBound(ref poly_tr, modifier) => {
+                hir::TraitTyParamBound(ref poly_tr, modifier) => {
                     let tr = &poly_tr.trait_ref;
                     let last_seg = tr.path.segments.last().unwrap();
                     let mut insert = Vec::new();
@@ -1497,10 +1498,10 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                         }
                     }
                 }
-                let new_types = data.types.map(|t| {
+                let new_types = data.types.iter().map(|t| {
                     self.rebuild_arg_ty_or_output(&**t, lifetime, anon_nums, region_names)
-                });
-                let new_bindings = data.bindings.map(|b| {
+                }).collect();
+                let new_bindings = data.bindings.iter().map(|b| {
                     hir::TypeBinding {
                         id: b.id,
                         name: b.name,
@@ -1510,7 +1511,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                                                           region_names),
                         span: b.span
                     }
-                });
+                }).collect();
                 hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
                     lifetimes: new_lts,
                     types: new_types,

src/librustc_front/fold.rs

@@ -20,7 +20,7 @@ use syntax::codemap::{respan, Span, Spanned};
 use syntax::owned_slice::OwnedSlice;
 use syntax::ptr::P;
 use syntax::parse::token;
-use syntax::util::move_map::MoveMap;
+use syntax::util::MoveMap;
 
 pub trait Folder : Sized {
     // Any additions to this trait should happen in form

src/librustc_front/hir.rs

@@ -127,8 +127,8 @@ impl PathParameters {
     pub fn none() -> PathParameters {
         AngleBracketedParameters(AngleBracketedParameterData {
             lifetimes: Vec::new(),
-            types: OwnedSlice::empty(),
-            bindings: OwnedSlice::empty(),
+            types: OwnedSlice::new(),
+            bindings: OwnedSlice::new(),
         })
     }
 

src/librustc_front/print/pprust.rs

@@ -519,7 +519,7 @@ impl<'a> State<'a> {
             hir::TyBareFn(ref f) => {
                 let generics = hir::Generics {
                     lifetimes: f.lifetimes.clone(),
-                    ty_params: OwnedSlice::empty(),
+                    ty_params: OwnedSlice::new(),
                     where_clause: hir::WhereClause {
                         id: ast::DUMMY_NODE_ID,
                         predicates: Vec::new(),
@@ -2258,7 +2258,7 @@ impl<'a> State<'a> {
         }
         let generics = hir::Generics {
             lifetimes: Vec::new(),
-            ty_params: OwnedSlice::empty(),
+            ty_params: OwnedSlice::new(),
             where_clause: hir::WhereClause {
                 id: ast::DUMMY_NODE_ID,
                 predicates: Vec::new(),

src/librustc_front/util.rs

@@ -336,7 +336,7 @@ pub fn is_path(e: P<Expr>) -> bool {
 pub fn empty_generics() -> Generics {
     Generics {
         lifetimes: Vec::new(),
-        ty_params: OwnedSlice::empty(),
+        ty_params: OwnedSlice::new(),
         where_clause: WhereClause {
             id: DUMMY_NODE_ID,
             predicates: Vec::new(),
@@ -354,8 +354,8 @@ pub fn ident_to_path(s: Span, ident: Ident) -> Path {
             identifier: ident,
             parameters: hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
                 lifetimes: Vec::new(),
-                types: OwnedSlice::empty(),
-                bindings: OwnedSlice::empty(),
+                types: OwnedSlice::new(),
+                bindings: OwnedSlice::new(),
             }),
         }),
     }

src/libsyntax/ast.rs

@@ -262,8 +262,8 @@ impl PathParameters {
     pub fn none() -> PathParameters {
         AngleBracketedParameters(AngleBracketedParameterData {
             lifetimes: Vec::new(),
-            types: OwnedSlice::empty(),
-            bindings: OwnedSlice::empty(),
+            types: OwnedSlice::new(),
+            bindings: OwnedSlice::new(),
         })
     }
 

src/libsyntax/ast_util.rs

@@ -178,8 +178,8 @@ pub fn ident_to_path(s: Span, identifier: Ident) -> Path {
                 identifier: identifier,
                 parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
                     lifetimes: Vec::new(),
-                    types: OwnedSlice::empty(),
-                    bindings: OwnedSlice::empty(),
+                    types: OwnedSlice::new(),
+                    bindings: OwnedSlice::new(),
                 })
             }
         ),
@@ -239,7 +239,7 @@ pub fn struct_field_visibility(field: ast::StructField) -> Visibility {
 pub fn empty_generics() -> Generics {
     Generics {
         lifetimes: Vec::new(),
-        ty_params: OwnedSlice::empty(),
+        ty_params: OwnedSlice::new(),
         where_clause: WhereClause {
             id: DUMMY_NODE_ID,
             predicates: Vec::new(),

src/libsyntax/ext/build.rs

@@ -332,8 +332,8 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             identifier: last_identifier,
             parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
                 lifetimes: lifetimes,
-                types: OwnedSlice::from_vec(types),
-                bindings: OwnedSlice::from_vec(bindings),
+                types: OwnedSlice::from(types),
+                bindings: OwnedSlice::from(bindings),
             })
         });
         ast::Path {
@@ -370,8 +370,8 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             identifier: ident,
             parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
                 lifetimes: lifetimes,
-                types: OwnedSlice::from_vec(types),
-                bindings: OwnedSlice::from_vec(bindings),
+                types: OwnedSlice::from(types),
+                bindings: OwnedSlice::from(bindings),
             })
         });
 

src/libsyntax/ext/deriving/generic/mod.rs

@@ -204,11 +204,11 @@ use ext::build::AstBuilder;
 use codemap::{self, DUMMY_SP};
 use codemap::Span;
 use diagnostic::SpanHandler;
-use util::move_map::MoveMap;
 use owned_slice::OwnedSlice;
 use parse::token::{intern, InternedString};
 use parse::token::special_idents;
 use ptr::P;
+use util::MoveMap;
 
 use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty};
 
@@ -490,7 +490,7 @@ impl<'a> TraitDef<'a> {
 
         let Generics { mut lifetimes, ty_params, mut where_clause } =
             self.generics.to_generics(cx, self.span, type_ident, generics);
-        let mut ty_params = ty_params.into_vec();
+        let mut ty_params: Vec<_> = ty_params.into();
 
         // Copy the lifetimes
         lifetimes.extend(generics.lifetimes.iter().cloned());
@@ -516,7 +516,7 @@ impl<'a> TraitDef<'a> {
 
             cx.typaram(self.span,
                        ty_param.ident,
-                       OwnedSlice::from_vec(bounds),
+                       OwnedSlice::from(bounds),
                        None)
         }));
 
@@ -528,7 +528,7 @@ impl<'a> TraitDef<'a> {
                         span: self.span,
                         bound_lifetimes: wb.bound_lifetimes.clone(),
                         bounded_ty: wb.bounded_ty.clone(),
-                        bounds: OwnedSlice::from_vec(wb.bounds.iter().cloned().collect())
+                        bounds: wb.bounds.iter().cloned().collect()
                     })
                 }
                 ast::WherePredicate::RegionPredicate(ref rb) => {
@@ -579,7 +579,7 @@ impl<'a> TraitDef<'a> {
                         span: self.span,
                         bound_lifetimes: vec![],
                         bounded_ty: ty,
-                        bounds: OwnedSlice::from_vec(bounds),
+                        bounds: OwnedSlice::from(bounds),
                     };
 
                     let predicate = ast::WherePredicate::BoundPredicate(predicate);
@@ -590,17 +590,17 @@ impl<'a> TraitDef<'a> {
 
         let trait_generics = Generics {
             lifetimes: lifetimes,
-            ty_params: OwnedSlice::from_vec(ty_params),
+            ty_params: OwnedSlice::from(ty_params),
             where_clause: where_clause
         };
 
         // Create the reference to the trait.
         let trait_ref = cx.trait_ref(trait_path);
 
         // Create the type parameters on the `self` path.
-        let self_ty_params = generics.ty_params.map(|ty_param| {
+        let self_ty_params = generics.ty_params.iter().map(|ty_param| {
             cx.ty_ident(self.span, ty_param.ident)
-        });
+        }).collect();
 
         let self_lifetimes: Vec<ast::Lifetime> =
             generics.lifetimes
@@ -611,7 +611,7 @@ impl<'a> TraitDef<'a> {
         // Create the type of `self`.
         let self_type = cx.ty_path(
             cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes,
-                        self_ty_params.into_vec(), Vec::new()));
+                        self_ty_params, Vec::new()));
 
         let attr = cx.attribute(
             self.span,

src/libsyntax/ext/deriving/generic/ty.rs

@@ -169,15 +169,15 @@ impl<'a> Ty<'a> {
                    -> ast::Path {
         match *self {
             Self_ => {
-                let self_params = self_generics.ty_params.map(|ty_param| {
+                let self_params = self_generics.ty_params.iter().map(|ty_param| {
                     cx.ty_ident(span, ty_param.ident)
-                });
+                }).collect();
                 let lifetimes = self_generics.lifetimes.iter()
                                                        .map(|d| d.lifetime)
                                                        .collect();
 
                 cx.path_all(span, false, vec!(self_ty), lifetimes,
-                            self_params.into_vec(), Vec::new())
+                            self_params, Vec::new())
             }
             Literal(ref p) => {
                 p.to_path(cx, span, self_ty, self_generics)
@@ -208,7 +208,7 @@ fn mk_generics(lifetimes: Vec<ast::LifetimeDef>, ty_params: Vec<ast::TyParam>)
                -> Generics {
     Generics {
         lifetimes: lifetimes,
-        ty_params: OwnedSlice::from_vec(ty_params),
+        ty_params: OwnedSlice::from(ty_params),
         where_clause: ast::WhereClause {
             id: ast::DUMMY_NODE_ID,
             predicates: Vec::new(),

src/libsyntax/ext/expand.rs

@@ -32,6 +32,7 @@ use util::small_vector::SmallVector;
 use visit;
 use visit::Visitor;
 use std_inject;
+use util::MoveMap;
 
 use std::collections::HashSet;
 

src/libsyntax/fold.rs

@@ -26,8 +26,8 @@ use codemap::{respan, Span, Spanned};
 use owned_slice::OwnedSlice;
 use parse::token;
 use ptr::P;
+use util::MoveMap;
 use util::small_vector::SmallVector;
-use util::move_map::MoveMap;
 
 use std::rc::Rc;
 

src/libsyntax/lib.rs

@@ -62,8 +62,11 @@ macro_rules! panictry {
 }
 
 pub mod util {
+    pub use self::move_map::MoveMap;
+
     pub mod interner;
     pub mod lev_distance;
+    pub mod move_map;
     pub mod node_count;
     pub mod parser;
     #[cfg(test)]