make the basic_blocks field private

5 files changed, 52 insertions, 55 deletions

diff --git a/src/librustc_mir/transform/add_call_guards.rs b/src/librustc_mir/transform/add_call_guards.rs
index f829865255d..dee9227fd9b 100644
--- a/src/librustc_mir/transform/add_call_guards.rs
+++ b/src/librustc_mir/transform/add_call_guards.rs
@@ -40,7 +40,7 @@ pub struct AddCallGuards;
 
 impl<'tcx> MirPass<'tcx> for AddCallGuards {
     fn run_pass<'a>(&mut self, tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource, mir: &mut Mir<'tcx>) {
-        let mut pred_count = IndexVec::from_elem(0u32, &mir.basic_blocks);
+        let mut pred_count = IndexVec::from_elem(0u32, mir.basic_blocks());
 
         // Build the precedecessor map for the MIR
         for (_, data) in traversal::preorder(mir) {
@@ -54,13 +54,10 @@ impl<'tcx> MirPass<'tcx> for AddCallGuards {
         // We need a place to store the new blocks generated
         let mut new_blocks = Vec::new();
 
-        let bbs = mir.all_basic_blocks();
-        let cur_len = mir.basic_blocks.len();
+        let cur_len = mir.basic_blocks().len();
 
-        for &bb in &bbs {
-            let data = mir.basic_block_data_mut(bb);
-
-            match data.terminator {
+        for block in mir.basic_blocks_mut() {
+            match block.terminator {
                 Some(Terminator {
                     kind: TerminatorKind::Call {
                         destination: Some((_, ref mut destination)),
@@ -71,7 +68,7 @@ impl<'tcx> MirPass<'tcx> for AddCallGuards {
                     // It's a critical edge, break it
                     let call_guard = BasicBlockData {
                         statements: vec![],
-                        is_cleanup: data.is_cleanup,
+                        is_cleanup: block.is_cleanup,
                         terminator: Some(Terminator {
                             source_info: source_info,
                             kind: TerminatorKind::Goto { target: *destination }
@@ -90,7 +87,7 @@ impl<'tcx> MirPass<'tcx> for AddCallGuards {
         pretty::dump_mir(tcx, "break_cleanup_edges", &0, src, mir, None);
         debug!("Broke {} N edges", new_blocks.len());
 
-        mir.basic_blocks.extend(new_blocks);
+        mir.basic_blocks_mut().extend(new_blocks);
     }
 }
 
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
index 4d6838052de..3ebfef10d43 100644
--- a/src/librustc_mir/transform/promote_consts.rs
+++ b/src/librustc_mir/transform/promote_consts.rs
@@ -163,11 +163,12 @@ struct Promoter<'a, 'tcx: 'a> {
 
 impl<'a, 'tcx> Promoter<'a, 'tcx> {
     fn new_block(&mut self) -> BasicBlock {
-        self.promoted.basic_blocks.push(BasicBlockData {
+        let span = self.promoted.span;
+        self.promoted.basic_blocks_mut().push(BasicBlockData {
             statements: vec![],
             terminator: Some(Terminator {
                 source_info: SourceInfo {
-                    span: self.promoted.span,
+                    span: span,
                     scope: ARGUMENT_VISIBILITY_SCOPE
                 },
                 kind: TerminatorKind::Return
@@ -177,8 +178,8 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
     }
 
     fn assign(&mut self, dest: Lvalue<'tcx>, rvalue: Rvalue<'tcx>, span: Span) {
-        let last = self.promoted.basic_blocks.last().unwrap();
-        let data = &mut self.promoted.basic_blocks[last];
+        let last = self.promoted.basic_blocks().last().unwrap();
+        let data = &mut self.promoted[last];
         data.statements.push(Statement {
             source_info: SourceInfo {
                 span: span,
@@ -268,7 +269,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
         if stmt_idx < no_stmts {
             self.assign(Lvalue::Temp(new_temp), rvalue.unwrap(), source_info.span);
         } else {
-            let last = self.promoted.basic_blocks.last().unwrap();
+            let last = self.promoted.basic_blocks().last().unwrap();
             let new_target = self.new_block();
             let mut call = call.unwrap();
             match call {
@@ -277,7 +278,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                 }
                 _ => bug!()
             }
-            let terminator = &mut self.promoted.basic_blocks[last].terminator_mut();
+            let terminator = self.promoted[last].terminator_mut();
             terminator.source_info.span = source_info.span;
             terminator.kind = call;
         }
@@ -365,20 +366,20 @@ pub fn promote_candidates<'a, 'tcx>(mir: &mut Mir<'tcx>,
 
         let mut promoter = Promoter {
             source: mir,
-            promoted: Mir {
-                basic_blocks: IndexVec::new(),
-                visibility_scopes: Some(VisibilityScopeData {
+            promoted: Mir::new(
+                IndexVec::new(),
+                Some(VisibilityScopeData {
                     span: span,
                     parent_scope: None
                 }).into_iter().collect(),
-                promoted: IndexVec::new(),
-                return_ty: ty::FnConverging(ty),
-                var_decls: IndexVec::new(),
-                arg_decls: IndexVec::new(),
-                temp_decls: IndexVec::new(),
-                upvar_decls: vec![],
-                span: span
-            },
+                IndexVec::new(),
+                ty::FnConverging(ty),
+                IndexVec::new(),
+                IndexVec::new(),
+                IndexVec::new(),
+                vec![],
+                span
+            ),
             temps: &mut temps,
             keep_original: false
         };
@@ -388,7 +389,7 @@ pub fn promote_candidates<'a, 'tcx>(mir: &mut Mir<'tcx>,
 
     // Eliminate assignments to, and drops of promoted temps.
     let promoted = |index: Temp| temps[index] == TempState::PromotedOut;
-    for block in &mut mir.basic_blocks {
+    for block in mir.basic_blocks_mut() {
         block.statements.retain(|statement| {
             match statement.kind {
                 StatementKind::Assign(Lvalue::Temp(index), _) => {
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
index 3272d7276d5..73ecac55389 100644
--- a/src/librustc_mir/transform/qualify_consts.rs
+++ b/src/librustc_mir/transform/qualify_consts.rs
@@ -337,7 +337,7 @@ impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
     fn qualify_const(&mut self) -> Qualif {
         let mir = self.mir;
 
-        let mut seen_blocks = BitVector::new(mir.basic_blocks.len());
+        let mut seen_blocks = BitVector::new(mir.basic_blocks().len());
         let mut bb = START_BLOCK;
         loop {
             seen_blocks.insert(bb.index());
@@ -367,12 +367,12 @@ impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
                 TerminatorKind::Return => {
                     // Check for unused values. This usually means
                     // there are extra statements in the AST.
-                    for (i, _) in mir.temp_decls.iter_enumerated() {
-                        if self.temp_qualif[i].is_none() {
+                    for temp in mir.temp_decls.indices() {
+                        if self.temp_qualif[temp].is_none() {
                             continue;
                         }
 
-                        let state = self.temp_promotion_state[i];
+                        let state = self.temp_promotion_state[temp];
                         if let TempState::Defined { location, uses: 0 } = state {
                             let data = &mir[location.block];
                             let stmt_idx = location.statement_index;
diff --git a/src/librustc_mir/transform/simplify_cfg.rs b/src/librustc_mir/transform/simplify_cfg.rs
index a65e9b8c414..fcc82249953 100644
--- a/src/librustc_mir/transform/simplify_cfg.rs
+++ b/src/librustc_mir/transform/simplify_cfg.rs
@@ -60,7 +60,7 @@ impl<'l, 'tcx> MirPass<'tcx> for SimplifyCfg<'l> {
         pretty::dump_mir(tcx, "simplify_cfg", &format!("{}-after", self.label), src, mir, None);
 
         // FIXME: Should probably be moved into some kind of pass manager
-        mir.basic_blocks.raw.shrink_to_fit();
+        mir.basic_blocks_mut().raw.shrink_to_fit();
     }
 }
 
@@ -68,7 +68,7 @@ impl<'l> Pass for SimplifyCfg<'l> {}
 
 fn merge_consecutive_blocks(mir: &mut Mir) {
     // Build the precedecessor map for the MIR
-    let mut pred_count = IndexVec::from_elem(0u32, &mir.basic_blocks);
+    let mut pred_count = IndexVec::from_elem(0u32, mir.basic_blocks());
     for (_, data) in traversal::preorder(mir) {
         if let Some(ref term) = data.terminator {
             for &tgt in term.successors().iter() {
@@ -79,12 +79,11 @@ fn merge_consecutive_blocks(mir: &mut Mir) {
 
     loop {
         let mut changed = false;
-        let mut seen = BitVector::new(mir.basic_blocks.len());
+        let mut seen = BitVector::new(mir.basic_blocks().len());
         let mut worklist = vec![START_BLOCK];
         while let Some(bb) = worklist.pop() {
             // Temporarily take ownership of the terminator we're modifying to keep borrowck happy
-            let mut terminator = mir.basic_block_data_mut(bb).terminator.take()
-                .expect("invalid terminator state");
+            let mut terminator = mir[bb].terminator.take().expect("invalid terminator state");
 
             // See if we can merge the target block into this one
             loop {
@@ -96,8 +95,8 @@ fn merge_consecutive_blocks(mir: &mut Mir) {
                         break;
                     }
 
-                    let num_insts = mir.basic_block_data(target).statements.len();
-                    match mir.basic_block_data(target).terminator().kind {
+                    let num_insts = mir[target].statements.len();
+                    match mir[target].terminator().kind {
                         TerminatorKind::Goto { target: new_target } if num_insts == 0 => {
                             inner_change = true;
                             terminator.kind = TerminatorKind::Goto { target: new_target };
@@ -108,12 +107,12 @@ fn merge_consecutive_blocks(mir: &mut Mir) {
                             inner_change = true;
                             let mut stmts = Vec::new();
                             {
-                                let target_data = mir.basic_block_data_mut(target);
+                                let target_data = &mut mir[target];
                                 mem::swap(&mut stmts, &mut target_data.statements);
                                 mem::swap(&mut terminator, target_data.terminator_mut());
                             }
 
-                            mir.basic_block_data_mut(bb).statements.append(&mut stmts);
+                            mir[bb].statements.append(&mut stmts);
                         }
                         _ => {}
                     };
@@ -122,7 +121,7 @@ fn merge_consecutive_blocks(mir: &mut Mir) {
                 for target in terminator.successors_mut() {
                     let new_target = match final_target(mir, *target) {
                         Some(new_target) => new_target,
-                        None if mir.basic_block_data(bb).statements.is_empty() => bb,
+                        None if mir[bb].statements.is_empty() => bb,
                         None => continue
                     };
                     if *target != new_target {
@@ -139,9 +138,9 @@ fn merge_consecutive_blocks(mir: &mut Mir) {
                 }
             }
 
-            mir.basic_block_data_mut(bb).terminator = Some(terminator);
+            mir[bb].terminator = Some(terminator);
 
-            for succ in mir.basic_block_data(bb).terminator().successors().iter() {
+            for succ in mir[bb].terminator().successors().iter() {
                 if seen.insert(succ.index()) {
                     worklist.push(*succ);
                 }
@@ -159,11 +158,11 @@ fn final_target(mir: &Mir, mut target: BasicBlock) -> Option<BasicBlock> {
     // Keep track of already seen blocks to detect loops
     let mut seen: Vec<BasicBlock> = Vec::with_capacity(8);
 
-    while mir.basic_block_data(target).statements.is_empty() {
+    while mir[target].statements.is_empty() {
         // NB -- terminator may have been swapped with `None` in
         // merge_consecutive_blocks, in which case we have a cycle and just want
         // to stop
-        match mir.basic_block_data(target).terminator {
+        match mir[target].terminator {
             Some(Terminator { kind: TerminatorKind::Goto { target: next }, .. }) =>  {
                 if seen.contains(&next) {
                     return None;
@@ -182,8 +181,7 @@ fn simplify_branches(mir: &mut Mir) {
     loop {
         let mut changed = false;
 
-        for bb in mir.all_basic_blocks() {
-            let basic_block = mir.basic_block_data_mut(bb);
+        for (_, basic_block) in mir.basic_blocks_mut().iter_enumerated_mut() {
             let mut terminator = basic_block.terminator_mut();
             terminator.kind = match terminator.kind {
                 TerminatorKind::If { ref targets, .. } if targets.0 == targets.1 => {
@@ -228,13 +226,14 @@ fn simplify_branches(mir: &mut Mir) {
 }
 
 fn remove_dead_blocks(mir: &mut Mir) {
-    let mut seen = BitVector::new(mir.basic_blocks.len());
+    let mut seen = BitVector::new(mir.basic_blocks().len());
     for (bb, _) in traversal::preorder(mir) {
         seen.insert(bb.index());
     }
 
-    let num_blocks = mir.basic_blocks.len();
+    let basic_blocks = mir.basic_blocks_mut();
 
+    let num_blocks = basic_blocks.len();
     let mut replacements : Vec<_> = (0..num_blocks).map(BasicBlock::new).collect();
     let mut used_blocks = 0;
     for alive_index in seen.iter() {
@@ -242,14 +241,14 @@ fn remove_dead_blocks(mir: &mut Mir) {
         if alive_index != used_blocks {
             // Swap the next alive block data with the current available slot. Since alive_index is
             // non-decreasing this is a valid operation.
-            mir.basic_blocks.raw.swap(alive_index, used_blocks);
+            basic_blocks.raw.swap(alive_index, used_blocks);
         }
         used_blocks += 1;
     }
-    mir.basic_blocks.raw.truncate(used_blocks);
+    basic_blocks.raw.truncate(used_blocks);
 
-    for bb in mir.all_basic_blocks() {
-        for target in mir.basic_block_data_mut(bb).terminator_mut().successors_mut() {
+    for block in basic_blocks {
+        for target in block.terminator_mut().successors_mut() {
             *target = replacements[target.index()];
         }
     }
diff --git a/src/librustc_mir/transform/type_check.rs b/src/librustc_mir/transform/type_check.rs
index ab402a7f881..16ea4780bb3 100644
--- a/src/librustc_mir/transform/type_check.rs
+++ b/src/librustc_mir/transform/type_check.rs
@@ -626,7 +626,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                         bb: BasicBlock,
                         iscleanuppad: bool)
     {
-        if mir.basic_block_data(bb).is_cleanup != iscleanuppad {
+        if mir[bb].is_cleanup != iscleanuppad {
             span_mirbug!(self, ctxt, "cleanuppad mismatch: {:?} should be {:?}",
                          bb, iscleanuppad);
         }
@@ -635,7 +635,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
     fn typeck_mir(&mut self, mir: &Mir<'tcx>) {
         self.last_span = mir.span;
         debug!("run_on_mir: {:?}", mir.span);
-        for block in &mir.basic_blocks {
+        for block in mir.basic_blocks() {
             for stmt in &block.statements {
                 if stmt.source_info.span != DUMMY_SP {
                     self.last_span = stmt.source_info.span;