Use OwnedSlice in HIR and update other crates using HIR

petrochenkov · petrochenkov · commit 6ba2602a2fd2 · 2015-12-08T21:19:06.000+03:00
diff --git a/src/librustc/front/map/collector.rs b/src/librustc/front/map/collector.rs
@@ -16,14 +16,15 @@ use rustc_front::util;
 use rustc_front::intravisit::{self, Visitor};
 use middle::def_id::{CRATE_DEF_INDEX, DefIndex};
 use std::iter::repeat;
+use std::vec;
 use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
 use syntax::codemap::Span;
 
 /// A Visitor that walks over an AST and collects Node's into an AST
 /// Map.
 pub struct NodeCollector<'ast> {
     pub krate: &'ast Crate,
-    pub map: Vec<MapEntry<'ast>>,
+    pub map: vec::Vec<MapEntry<'ast>>,
     pub definitions: Definitions,
     pub parent_node: NodeId,
 }
@@ -50,7 +51,7 @@ impl<'ast> NodeCollector<'ast> {
                   parent: &'ast InlinedParent,
                   parent_node: NodeId,
                   parent_def_path: DefPath,
-                  map: Vec<MapEntry<'ast>>,
+                  map: vec::Vec<MapEntry<'ast>>,
                   definitions: Definitions)
                   -> NodeCollector<'ast> {
         let mut collector = NodeCollector {
diff --git a/src/librustc/front/map/mod.rs b/src/librustc/front/map/mod.rs
@@ -35,6 +35,7 @@ use std::io;
 use std::iter;
 use std::mem;
 use std::slice;
+use std::vec;
 
 pub mod blocks;
 mod collector;
@@ -164,7 +165,7 @@ impl<'ast> Clone for MapEntry<'ast> {
 
 #[derive(Debug)]
 pub struct InlinedParent {
-    path: Vec<PathElem>,
+    path: vec::Vec<PathElem>,
     ii: InlinedItem
 }
 
@@ -261,7 +262,7 @@ pub struct Map<'ast> {
     ///
     /// Also, indexing is pretty quick when you've got a vector and
     /// plain old integers.
-    map: RefCell<Vec<MapEntry<'ast>>>,
+    map: RefCell<vec::Vec<MapEntry<'ast>>>,
 
     definitions: RefCell<Definitions>,
 }
@@ -842,7 +843,7 @@ pub fn map_crate<'ast>(forest: &'ast mut Forest) -> Map<'ast> {
 /// crate.  The `path` should be the path to the item but should not include
 /// the item itself.
 pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
-                                          path: Vec<PathElem>,
+                                          path: vec::Vec<PathElem>,
                                           def_path: DefPath,
                                           ii: InlinedItem,
                                           fold_ops: F)
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
@@ -516,7 +516,7 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
         ty::TyEnum(adt, _) | ty::TyStruct(adt, _)  => {
             let v = adt.variant_of_ctor(ctor);
             if let VariantKind::Struct = v.kind() {
-                let field_pats: Vec<_> = v.fields.iter()
+                let field_pats: hir::Vec<_> = v.fields.iter()
                     .zip(pats)
                     .filter(|&(_, ref pat)| pat.node != hir::PatWild)
                     .map(|(field, pat)| Spanned {
@@ -539,14 +539,14 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
                ty::TyArray(_, n) => match ctor {
                     &Single => {
                         assert_eq!(pats_len, n);
-                        hir::PatVec(pats.collect(), None, vec!())
+                        hir::PatVec(pats.collect(), None, hir::Vec::new())
                     },
                     _ => unreachable!()
                 },
                 ty::TySlice(_) => match ctor {
                     &Slice(n) => {
                         assert_eq!(pats_len, n);
-                        hir::PatVec(pats.collect(), None, vec!())
+                        hir::PatVec(pats.collect(), None, hir::Vec::new())
                     },
                     _ => unreachable!()
                 },
@@ -561,7 +561,7 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
 
         ty::TyArray(_, len) => {
             assert_eq!(pats_len, len);
-            hir::PatVec(pats.collect(), None, vec![])
+            hir::PatVec(pats.collect(), None, hir::Vec::new())
         }
 
         _ => {
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
@@ -352,14 +352,14 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr, span: Span) -> P<hir::Pat>
 
         hir::ExprVec(ref exprs) => {
             let pats = exprs.iter().map(|expr| const_expr_to_pat(tcx, &**expr, span)).collect();
-            hir::PatVec(pats, None, vec![])
+            hir::PatVec(pats, None, hir::Vec::new())
         }
 
         hir::ExprPath(_, ref path) => {
             let opt_def = tcx.def_map.borrow().get(&expr.id).map(|d| d.full_def());
             match opt_def {
                 Some(def::DefStruct(..)) =>
-                    hir::PatStruct(path.clone(), vec![], false),
+                    hir::PatStruct(path.clone(), hir::Vec::new(), false),
                 Some(def::DefVariant(..)) =>
                     hir::PatEnum(path.clone(), None),
                 _ => {
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -324,7 +324,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
         self.delegate.consume(consume_id, consume_span, cmt, mode);
     }
 
-    fn consume_exprs(&mut self, exprs: &Vec<P<hir::Expr>>) {
+    fn consume_exprs(&mut self, exprs: &[P<hir::Expr>]) {
         for expr in exprs {
             self.consume_expr(&**expr);
         }
@@ -647,7 +647,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
 
     fn walk_struct_expr(&mut self,
                         _expr: &hir::Expr,
-                        fields: &Vec<hir::Field>,
+                        fields: &[hir::Field],
                         opt_with: &Option<P<hir::Expr>>) {
         // Consume the expressions supplying values for each field.
         for field in fields {
@@ -693,7 +693,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
         self.walk_expr(with_expr);
 
         fn contains_field_named(field: ty::FieldDef,
-                                fields: &Vec<hir::Field>)
+                                fields: &[hir::Field])
                                 -> bool
         {
             fields.iter().any(
diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs
@@ -1254,7 +1254,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
         let mut lifetimes = Vec::new();
         for lt in add {
             lifetimes.push(hir::LifetimeDef { lifetime: *lt,
-                                              bounds: Vec::new() });
+                                              bounds: hir::Vec::new() });
         }
         for lt in &generics.lifetimes {
             if keep.contains(&lt.lifetime.name) ||
@@ -1263,7 +1263,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
             }
         }
         hir::Generics {
-            lifetimes: lifetimes,
+            lifetimes: lifetimes.into(),
             ty_params: ty_params,
             where_clause: where_clause,
         }
@@ -1274,7 +1274,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                        lifetime: hir::Lifetime,
                        anon_nums: &HashSet<u32>,
                        region_names: &HashSet<ast::Name>)
-                       -> Vec<hir::Arg> {
+                       -> hir::Vec<hir::Arg> {
         let mut new_inputs = Vec::new();
         for arg in inputs {
             let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime,
@@ -1286,7 +1286,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
             };
             new_inputs.push(possibly_new_arg);
         }
-        new_inputs
+        new_inputs.into()
     }
 
     fn rebuild_output(&self, ty: &hir::FunctionRetTy,
@@ -1513,7 +1513,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                     }
                 }).collect();
                 hir::AngleBracketedParameters(hir::AngleBracketedParameterData {
-                    lifetimes: new_lts,
+                    lifetimes: new_lts.into(),
                     types: new_types,
                     bindings: new_bindings,
                })
@@ -1529,7 +1529,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
         hir::Path {
             span: path.span,
             global: path.global,
-            segments: new_segs
+            segments: new_segs.into()
         }
     }
 }
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -79,10 +79,10 @@ struct LifetimeContext<'a> {
 enum ScopeChain<'a> {
     /// EarlyScope(i, ['a, 'b, ...], s) extends s with early-bound
     /// lifetimes, assigning indexes 'a => i, 'b => i+1, ... etc.
-    EarlyScope(subst::ParamSpace, &'a Vec<hir::LifetimeDef>, Scope<'a>),
+    EarlyScope(subst::ParamSpace, &'a [hir::LifetimeDef], Scope<'a>),
     /// LateScope(['a, 'b, ...], s) extends s with late-bound
     /// lifetimes introduced by the declaration binder_id.
-    LateScope(&'a Vec<hir::LifetimeDef>, Scope<'a>),
+    LateScope(&'a [hir::LifetimeDef], Scope<'a>),
     /// lifetimes introduced by items within a code block are scoped
     /// to that block.
     BlockScope(region::DestructionScopeData, Scope<'a>),
@@ -661,7 +661,7 @@ impl<'a> LifetimeContext<'a> {
                     lifetime_ref.name);
     }
 
-    fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<hir::LifetimeDef>) {
+    fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &[hir::LifetimeDef]) {
         for i in 0..lifetimes.len() {
             let lifetime_i = &lifetimes[i];
 
@@ -753,7 +753,7 @@ impl<'a> LifetimeContext<'a> {
     }
 }
 
-fn search_lifetimes<'a>(lifetimes: &'a Vec<hir::LifetimeDef>,
+fn search_lifetimes<'a>(lifetimes: &'a [hir::LifetimeDef],
                     lifetime_ref: &hir::Lifetime)
                     -> Option<(u32, &'a hir::Lifetime)> {
     for (i, lifetime_decl) in lifetimes.iter().enumerate() {
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
@@ -80,7 +80,7 @@ struct Annotator<'a, 'tcx: 'a> {
 impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {
     // Determine the stability for a node based on its attributes and inherited
     // stability. The stability is recorded in the index and used as the parent.
-    fn annotate<F>(&mut self, id: NodeId, attrs: &Vec<Attribute>,
+    fn annotate<F>(&mut self, id: NodeId, attrs: &[Attribute],
                    item_sp: Span, kind: AnnotationKind, visit_children: F)
         where F: FnOnce(&mut Annotator)
     {
diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs
@@ -52,7 +52,7 @@ use util;
 use std::fmt;
 use serialize::{Encodable, Encoder, Decoder};
 
-pub type Vec<T> = ::std::vec::Vec<T>;
+pub type Vec<T> = OwnedSlice<T>;
 
 macro_rules! hir_vec {
     ($elem:expr; $n:expr) => (
diff --git a/src/librustc_mir/hair/cx/pattern.rs b/src/librustc_mir/hair/cx/pattern.rs
@@ -253,7 +253,7 @@ impl<'patcx, 'cx, 'tcx> PatCx<'patcx, 'cx, 'tcx> {
         }
     }
 
-    fn to_pats(&mut self, pats: &'tcx Vec<P<hir::Pat>>) -> Vec<Pattern<'tcx>> {
+    fn to_pats(&mut self, pats: &'tcx [P<hir::Pat>]) -> Vec<Pattern<'tcx>> {
         pats.iter().map(|p| self.to_pat(p)).collect()
     }
 
@@ -264,9 +264,9 @@ impl<'patcx, 'cx, 'tcx> PatCx<'patcx, 'cx, 'tcx> {
     fn slice_or_array_pattern(&mut self,
                               pat: &'tcx hir::Pat,
                               ty: Ty<'tcx>,
-                              prefix: &'tcx Vec<P<hir::Pat>>,
+                              prefix: &'tcx [P<hir::Pat>],
                               slice: &'tcx Option<P<hir::Pat>>,
-                              suffix: &'tcx Vec<P<hir::Pat>>)
+                              suffix: &'tcx [P<hir::Pat>])
                               -> PatternKind<'tcx> {
         match ty.sty {
             ty::TySlice(..) => {
diff --git a/src/librustc_mir/hair/cx/to_ref.rs b/src/librustc_mir/hair/cx/to_ref.rs
@@ -11,6 +11,7 @@
 use hair::*;
 
 use rustc_front::hir;
+use syntax::owned_slice::OwnedSlice;
 use syntax::ptr::P;
 
 pub trait ToRef {
@@ -61,3 +62,14 @@ impl<'a,'tcx:'a,T,U> ToRef for &'tcx Vec<T>
         self.iter().map(|expr| expr.to_ref()).collect()
     }
 }
+
+
+impl<'a,'tcx:'a,T,U> ToRef for &'tcx OwnedSlice<T>
+    where &'tcx T: ToRef<Output=U>
+{
+    type Output = Vec<U>;
+
+    fn to_ref(self) -> Vec<U> {
+        self.iter().map(|expr| expr.to_ref()).collect()
+    }
+}
diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs
@@ -1010,7 +1010,7 @@ pub fn trans_static(ccx: &CrateContext,
                     m: hir::Mutability,
                     expr: &hir::Expr,
                     id: ast::NodeId,
-                    attrs: &Vec<ast::Attribute>)
+                    attrs: &[ast::Attribute])
                     -> Result<ValueRef, ConstEvalErr> {
     unsafe {
         let _icx = push_ctxt("trans_static");

Original file line number	Diff line number	Diff line change
`@@ -1254,7 +1254,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1254`	`1254`	`let mut lifetimes = Vec::new();`
`1255`	`1255`	`for lt in add {`
`1256`	`1256`	`lifetimes.push(hir::LifetimeDef { lifetime: *lt,`
`1257`		`- bounds: Vec::new() });`
	`1257`	`+ bounds: hir::Vec::new() });`
`1258`	`1258`	`}`
`1259`	`1259`	`for lt in &generics.lifetimes {`
`1260`	`1260`	`if keep.contains(&lt.lifetime.name) \|\|`
`@@ -1263,7 +1263,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1263`	`1263`	`}`
`1264`	`1264`	`}`
`1265`	`1265`	`hir::Generics {`
`1266`		`- lifetimes: lifetimes,`
	`1266`	`+ lifetimes: lifetimes.into(),`
`1267`	`1267`	`ty_params: ty_params,`
`1268`	`1268`	`where_clause: where_clause,`
`1269`	`1269`	`}`
`@@ -1274,7 +1274,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1274`	`1274`	`lifetime: hir::Lifetime,`
`1275`	`1275`	`anon_nums: &HashSet<u32>,`
`1276`	`1276`	`region_names: &HashSet<ast::Name>)`
`1277`		`- -> Vec<hir::Arg> {`
	`1277`	`+ -> hir::Vec<hir::Arg> {`
`1278`	`1278`	`let mut new_inputs = Vec::new();`
`1279`	`1279`	`for arg in inputs {`
`1280`	`1280`	`let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime,`
`@@ -1286,7 +1286,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1286`	`1286`	`};`
`1287`	`1287`	`new_inputs.push(possibly_new_arg);`
`1288`	`1288`	`}`
`1289`		`- new_inputs`
	`1289`	`+ new_inputs.into()`
`1290`	`1290`	`}`
`1291`	`1291`
`1292`	`1292`	`fn rebuild_output(&self, ty: &hir::FunctionRetTy,`
`@@ -1513,7 +1513,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1513`	`1513`	`}`
`1514`	`1514`	`}).collect();`
`1515`	`1515`	`hir::AngleBracketedParameters(hir::AngleBracketedParameterData {`
`1516`		`- lifetimes: new_lts,`
	`1516`	`+ lifetimes: new_lts.into(),`
`1517`	`1517`	`types: new_types,`
`1518`	`1518`	`bindings: new_bindings,`
`1519`	`1519`	`})`
`@@ -1529,7 +1529,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {`
`1529`	`1529`	`hir::Path {`
`1530`	`1530`	`span: path.span,`
`1531`	`1531`	`global: path.global,`
`1532`		`- segments: new_segs`
	`1532`	`+ segments: new_segs.into()`
`1533`	`1533`	`}`
`1534`	`1534`	`}`
`1535`	`1535`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ struct Annotator<'a, 'tcx: 'a> {`
`80`	`80`	`impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {`
`81`	`81`	`// Determine the stability for a node based on its attributes and inherited`
`82`	`82`	`// stability. The stability is recorded in the index and used as the parent.`
`83`		`- fn annotate<F>(&mut self, id: NodeId, attrs: &Vec<Attribute>,`
	`83`	`+ fn annotate<F>(&mut self, id: NodeId, attrs: &[Attribute],`
`84`	`84`	`item_sp: Span, kind: AnnotationKind, visit_children: F)`
`85`	`85`	`where F: FnOnce(&mut Annotator)`
`86`	`86`	`{`
Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ impl<'patcx, 'cx, 'tcx> PatCx<'patcx, 'cx, 'tcx> {`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`
`256`		`- fn to_pats(&mut self, pats: &'tcx Vec<P<hir::Pat>>) -> Vec<Pattern<'tcx>> {`
	`256`	`+ fn to_pats(&mut self, pats: &'tcx [P<hir::Pat>]) -> Vec<Pattern<'tcx>> {`
`257`	`257`	`pats.iter().map(\|p\| self.to_pat(p)).collect()`
`258`	`258`	`}`
`259`	`259`
`@@ -264,9 +264,9 @@ impl<'patcx, 'cx, 'tcx> PatCx<'patcx, 'cx, 'tcx> {`
`264`	`264`	`fn slice_or_array_pattern(&mut self,`
`265`	`265`	`pat: &'tcx hir::Pat,`
`266`	`266`	`ty: Ty<'tcx>,`
`267`		`- prefix: &'tcx Vec<P<hir::Pat>>,`
	`267`	`+ prefix: &'tcx [P<hir::Pat>],`
`268`	`268`	`slice: &'tcx Option<P<hir::Pat>>,`
`269`		`- suffix: &'tcx Vec<P<hir::Pat>>)`
	`269`	`+ suffix: &'tcx [P<hir::Pat>])`
`270`	`270`	`-> PatternKind<'tcx> {`
`271`	`271`	`match ty.sty {`
`272`	`272`	`ty::TySlice(..) => {`