rename IdxVec => IndexVec

Author: arielb1

src/librustc/mir/cache.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 use std::cell::{Ref, RefCell};
-use rustc_data_structures::indexed_vec::IdxVec;
+use rustc_data_structures::indexed_vec::IndexVec;
 
 use mir::repr::{Mir, BasicBlock};
 
 use rustc_serialize as serialize;
 
 #[derive(Clone)]
 pub struct Cache {
-    predecessors: RefCell<Option<IdxVec<BasicBlock, Vec<BasicBlock>>>>
+    predecessors: RefCell<Option<IndexVec<BasicBlock, Vec<BasicBlock>>>>
 }
 
 
@@ -46,7 +46,7 @@ impl Cache {
         *self.predecessors.borrow_mut() = None;
     }
 
-    pub fn predecessors(&self, mir: &Mir) -> Ref<IdxVec<BasicBlock, Vec<BasicBlock>>> {
+    pub fn predecessors(&self, mir: &Mir) -> Ref<IndexVec<BasicBlock, Vec<BasicBlock>>> {
         if self.predecessors.borrow().is_none() {
             *self.predecessors.borrow_mut() = Some(calculate_predecessors(mir));
         }
@@ -55,8 +55,8 @@ impl Cache {
     }
 }
 
-fn calculate_predecessors(mir: &Mir) -> IdxVec<BasicBlock, Vec<BasicBlock>> {
-    let mut result = IdxVec::from_elem(vec![], mir.basic_blocks());
+fn calculate_predecessors(mir: &Mir) -> IndexVec<BasicBlock, Vec<BasicBlock>> {
+    let mut result = IndexVec::from_elem(vec![], mir.basic_blocks());
     for (bb, data) in mir.basic_blocks().iter_enumerated() {
         if let Some(ref term) = data.terminator {
             for &tgt in term.successors().iter() {

src/librustc/mir/repr.rs

@@ -11,7 +11,7 @@
 use graphviz::IntoCow;
 use middle::const_val::ConstVal;
 use rustc_const_math::{ConstUsize, ConstInt, ConstMathErr};
-use rustc_data_structures::indexed_vec::{IdxVec, Idx};
+use rustc_data_structures::indexed_vec::{IndexVec, Idx};
 use hir::def_id::DefId;
 use ty::subst::Substs;
 use ty::{self, AdtDef, ClosureSubsts, FnOutput, Region, Ty};
@@ -58,32 +58,32 @@ macro_rules! newtype_index {
 pub struct Mir<'tcx> {
     /// List of basic blocks. References to basic block use a newtyped index type `BasicBlock`
     /// that indexes into this vector.
-    basic_blocks: IdxVec<BasicBlock, BasicBlockData<'tcx>>,
+    basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
 
     /// List of lexical scopes; these are referenced by statements and
     /// used (eventually) for debuginfo. Indexed by a `ScopeId`.
-    pub scopes: IdxVec<ScopeId, ScopeData>,
+    pub scopes: IndexVec<ScopeId, ScopeData>,
 
     /// Rvalues promoted from this function, such as borrows of constants.
     /// Each of them is the Mir of a constant with the fn's type parameters
     /// in scope, but no vars or args and a separate set of temps.
-    pub promoted: IdxVec<Promoted, Mir<'tcx>>,
+    pub promoted: IndexVec<Promoted, Mir<'tcx>>,
 
     /// Return type of the function.
     pub return_ty: FnOutput<'tcx>,
 
     /// Variables: these are stack slots corresponding to user variables. They may be
     /// assigned many times.
-    pub var_decls: IdxVec<Var, VarDecl<'tcx>>,
+    pub var_decls: IndexVec<Var, VarDecl<'tcx>>,
 
     /// Args: these are stack slots corresponding to the input arguments.
-    pub arg_decls: IdxVec<Arg, ArgDecl<'tcx>>,
+    pub arg_decls: IndexVec<Arg, ArgDecl<'tcx>>,
 
     /// Temp declarations: stack slots that for temporaries created by
     /// the compiler. These are assigned once, but they are not SSA
     /// values in that it is possible to borrow them and mutate them
     /// through the resulting reference.
-    pub temp_decls: IdxVec<Temp, TempDecl<'tcx>>,
+    pub temp_decls: IndexVec<Temp, TempDecl<'tcx>>,
 
     /// Names and capture modes of all the closure upvars, assuming
     /// the first argument is either the closure or a reference to it.
@@ -100,13 +100,13 @@ pub struct Mir<'tcx> {
 pub const START_BLOCK: BasicBlock = BasicBlock(0);
 
 impl<'tcx> Mir<'tcx> {
-    pub fn new(basic_blocks: IdxVec<BasicBlock, BasicBlockData<'tcx>>,
-               scopes: IdxVec<ScopeId, ScopeData>,
-               promoted: IdxVec<Promoted, Mir<'tcx>>,
+    pub fn new(basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
+               scopes: IndexVec<ScopeId, ScopeData>,
+               promoted: IndexVec<Promoted, Mir<'tcx>>,
                return_ty: FnOutput<'tcx>,
-               var_decls: IdxVec<Var, VarDecl<'tcx>>,
-               arg_decls: IdxVec<Arg, ArgDecl<'tcx>>,
-               temp_decls: IdxVec<Temp, TempDecl<'tcx>>,
+               var_decls: IndexVec<Var, VarDecl<'tcx>>,
+               arg_decls: IndexVec<Arg, ArgDecl<'tcx>>,
+               temp_decls: IndexVec<Temp, TempDecl<'tcx>>,
                upvar_decls: Vec<UpvarDecl>,
                span: Span) -> Self
     {
@@ -125,18 +125,18 @@ impl<'tcx> Mir<'tcx> {
     }
 
     #[inline]
-    pub fn basic_blocks(&self) -> &IdxVec<BasicBlock, BasicBlockData<'tcx>> {
+    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
         &self.basic_blocks
     }
 
     #[inline]
-    pub fn basic_blocks_mut(&mut self) -> &mut IdxVec<BasicBlock, BasicBlockData<'tcx>> {
+    pub fn basic_blocks_mut(&mut self) -> &mut IndexVec<BasicBlock, BasicBlockData<'tcx>> {
         self.cache.invalidate();
         &mut self.basic_blocks
     }
 
     #[inline]
-    pub fn predecessors(&self) -> Ref<IdxVec<BasicBlock, Vec<BasicBlock>>> {
+    pub fn predecessors(&self) -> Ref<IndexVec<BasicBlock, Vec<BasicBlock>>> {
         self.cache.predecessors(self)
     }
 

src/librustc_borrowck/borrowck/mir/gather_moves.rs

@@ -12,7 +12,7 @@
 use rustc::ty::{FnOutput, TyCtxt};
 use rustc::mir::repr::*;
 use rustc::util::nodemap::FnvHashMap;
-use rustc_data_structures::indexed_vec::{Idx, IdxVec};
+use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 
 use std::cell::{Cell};
 use std::collections::hash_map::Entry;
@@ -240,9 +240,9 @@ struct MovePathDataBuilder<'a, 'tcx: 'a> {
 /// Tables mapping from an l-value to its MovePathIndex.
 #[derive(Debug)]
 pub struct MovePathLookup<'tcx> {
-    vars: IdxVec<Var, Option<MovePathIndex>>,
-    temps: IdxVec<Temp, Option<MovePathIndex>>,
-    args: IdxVec<Arg, Option<MovePathIndex>>,
+    vars: IndexVec<Var, Option<MovePathIndex>>,
+    temps: IndexVec<Temp, Option<MovePathIndex>>,
+    args: IndexVec<Arg, Option<MovePathIndex>>,
 
     /// The move path representing the return value is constructed
     /// lazily when we first encounter it in the input MIR.
@@ -297,9 +297,9 @@ impl Lookup<MovePathIndex> {
 impl<'tcx> MovePathLookup<'tcx> {
     fn new(mir: &Mir) -> Self {
         MovePathLookup {
-            vars: IdxVec::from_elem(None, &mir.var_decls),
-            temps: IdxVec::from_elem(None, &mir.temp_decls),
-            args: IdxVec::from_elem(None, &mir.arg_decls),
+            vars: IndexVec::from_elem(None, &mir.var_decls),
+            temps: IndexVec::from_elem(None, &mir.temp_decls),
+            args: IndexVec::from_elem(None, &mir.arg_decls),
             statics: None,
             return_ptr: None,
             projections: vec![],
@@ -313,7 +313,7 @@ impl<'tcx> MovePathLookup<'tcx> {
         i
     }
 
-    fn lookup_or_generate<I: Idx>(vec: &mut IdxVec<I, Option<MovePathIndex>>,
+    fn lookup_or_generate<I: Idx>(vec: &mut IndexVec<I, Option<MovePathIndex>>,
                                   idx: I,
                                   next_index: &mut MovePathIndex)
                                   -> Lookup<MovePathIndex> {

src/librustc_borrowck/borrowck/mir/patch.rs

@@ -11,14 +11,14 @@
 use super::gather_moves::Location;
 use rustc::ty::Ty;
 use rustc::mir::repr::*;
-use rustc_data_structures::indexed_vec::{IdxVec, Idx};
+use rustc_data_structures::indexed_vec::{IndexVec, Idx};
 use syntax::codemap::Span;
 
 /// This struct represents a patch to MIR, which can add
 /// new statements and basic blocks and patch over block
 /// terminators.
 pub struct MirPatch<'tcx> {
-    patch_map: IdxVec<BasicBlock, Option<TerminatorKind<'tcx>>>,
+    patch_map: IndexVec<BasicBlock, Option<TerminatorKind<'tcx>>>,
     new_blocks: Vec<BasicBlockData<'tcx>>,
     new_statements: Vec<(Location, StatementKind<'tcx>)>,
     new_temps: Vec<TempDecl<'tcx>>,
@@ -29,7 +29,7 @@ pub struct MirPatch<'tcx> {
 impl<'tcx> MirPatch<'tcx> {
     pub fn new(mir: &Mir<'tcx>) -> Self {
         let mut result = MirPatch {
-            patch_map: IdxVec::from_elem(None, mir.basic_blocks()),
+            patch_map: IndexVec::from_elem(None, mir.basic_blocks()),
             new_blocks: vec![],
             new_temps: vec![],
             new_statements: vec![],

src/librustc_data_structures/indexed_vec.rs

@@ -31,49 +31,49 @@ impl Idx for usize {
 }
 
 #[derive(Clone)]
-pub struct IdxVec<I: Idx, T> {
+pub struct IndexVec<I: Idx, T> {
     pub raw: Vec<T>,
     _marker: PhantomData<Fn(&I)>
 }
 
-impl<I: Idx, T: serialize::Encodable> serialize::Encodable for IdxVec<I, T> {
+impl<I: Idx, T: serialize::Encodable> serialize::Encodable for IndexVec<I, T> {
     fn encode<S: serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         serialize::Encodable::encode(&self.raw, s)
     }
 }
 
-impl<I: Idx, T: serialize::Decodable> serialize::Decodable for IdxVec<I, T> {
+impl<I: Idx, T: serialize::Decodable> serialize::Decodable for IndexVec<I, T> {
     fn decode<D: serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
         serialize::Decodable::decode(d).map(|v| {
-            IdxVec { raw: v, _marker: PhantomData }
+            IndexVec { raw: v, _marker: PhantomData }
         })
     }
 }
 
-impl<I: Idx, T: fmt::Debug> fmt::Debug for IdxVec<I, T> {
+impl<I: Idx, T: fmt::Debug> fmt::Debug for IndexVec<I, T> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&self.raw, fmt)
     }
 }
 
 pub type Enumerated<I, J> = iter::Map<iter::Enumerate<J>, IntoIdx<I>>;
 
-impl<I: Idx, T> IdxVec<I, T> {
+impl<I: Idx, T> IndexVec<I, T> {
     #[inline]
     pub fn new() -> Self {
-        IdxVec { raw: Vec::new(), _marker: PhantomData }
+        IndexVec { raw: Vec::new(), _marker: PhantomData }
     }
 
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
-        IdxVec { raw: Vec::with_capacity(capacity), _marker: PhantomData }
+        IndexVec { raw: Vec::with_capacity(capacity), _marker: PhantomData }
     }
 
     #[inline]
-    pub fn from_elem<S>(elem: T, universe: &IdxVec<I, S>) -> Self
+    pub fn from_elem<S>(elem: T, universe: &IndexVec<I, S>) -> Self
         where T: Clone
     {
-        IdxVec { raw: vec![elem; universe.len()], _marker: PhantomData }
+        IndexVec { raw: vec![elem; universe.len()], _marker: PhantomData }
     }
 
     #[inline]
@@ -137,7 +137,7 @@ impl<I: Idx, T> IdxVec<I, T> {
     }
 }
 
-impl<I: Idx, T> Index<I> for IdxVec<I, T> {
+impl<I: Idx, T> Index<I> for IndexVec<I, T> {
     type Output = T;
 
     #[inline]
@@ -146,28 +146,28 @@ impl<I: Idx, T> Index<I> for IdxVec<I, T> {
     }
 }
 
-impl<I: Idx, T> IndexMut<I> for IdxVec<I, T> {
+impl<I: Idx, T> IndexMut<I> for IndexVec<I, T> {
     #[inline]
     fn index_mut(&mut self, index: I) -> &mut T {
         &mut self.raw[index.index()]
     }
 }
 
-impl<I: Idx, T> Extend<T> for IdxVec<I, T> {
+impl<I: Idx, T> Extend<T> for IndexVec<I, T> {
     #[inline]
     fn extend<J: IntoIterator<Item = T>>(&mut self, iter: J) {
         self.raw.extend(iter);
     }
 }
 
-impl<I: Idx, T> FromIterator<T> for IdxVec<I, T> {
+impl<I: Idx, T> FromIterator<T> for IndexVec<I, T> {
     #[inline]
     fn from_iter<J>(iter: J) -> Self where J: IntoIterator<Item=T> {
-        IdxVec { raw: FromIterator::from_iter(iter), _marker: PhantomData }
+        IndexVec { raw: FromIterator::from_iter(iter), _marker: PhantomData }
     }
 }
 
-impl<I: Idx, T> IntoIterator for IdxVec<I, T> {
+impl<I: Idx, T> IntoIterator for IndexVec<I, T> {
     type Item = T;
     type IntoIter = vec::IntoIter<T>;
 
@@ -178,7 +178,7 @@ impl<I: Idx, T> IntoIterator for IdxVec<I, T> {
 
 }
 
-impl<'a, I: Idx, T> IntoIterator for &'a IdxVec<I, T> {
+impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T> {
     type Item = &'a T;
     type IntoIter = slice::Iter<'a, T>;
 
@@ -188,7 +188,7 @@ impl<'a, I: Idx, T> IntoIterator for &'a IdxVec<I, T> {
     }
 }
 
-impl<'a, I: Idx, T> IntoIterator for &'a mut IdxVec<I, T> {
+impl<'a, I: Idx, T> IntoIterator for &'a mut IndexVec<I, T> {
     type Item = &'a mut T;
     type IntoIter = slice::IterMut<'a, T>;