Address comments

Author: nagisa

src/librustc/mir/transform.rs

@@ -8,46 +8,27 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use mir::repr::{Mir, BasicBlockData, BasicBlock};
+use mir::repr::Mir;
 use mir::mir_map::MirMap;
 use middle::ty::ctxt;
 
 /// Contains various metadata about the pass.
 pub trait Pass {
-    /// Ordering of the pass. Lower value runs the pass earlier.
-    fn priority(&self) -> usize;
     // Possibly also `fn name()` and `fn should_run(Session)` etc.
 }
 
 /// Pass which inspects the whole MirMap.
-pub trait MirMapPass: Pass {
-    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>);
+pub trait MirMapPass<'tcx>: Pass {
+    fn run_pass(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>);
 }
 
 /// Pass which only inspects MIR of distinct functions.
-pub trait MirPass: Pass {
-    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, mir: &mut Mir<'tcx>);
+pub trait MirPass<'tcx>: Pass {
+    fn run_pass(&mut self, tcx: &ctxt<'tcx>, mir: &mut Mir<'tcx>);
 }
 
-/// Pass which only inspects basic blocks in MIR.
-///
-/// Invariant: The blocks are considered to be fully self-contained for the purposes of this pass –
-/// the pass may not change the list of successors of the block or apply any transformations to
-/// blocks based on the information collected during earlier runs of the pass.
-pub trait MirBlockPass: Pass {
-    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, bb: BasicBlock, data: &mut BasicBlockData<'tcx>);
-}
-
-impl<T: MirBlockPass> MirPass for T {
-    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, mir: &mut Mir<'tcx>) {
-        for (i, basic_block) in mir.basic_blocks.iter_mut().enumerate() {
-            MirBlockPass::run_pass(self, tcx, BasicBlock::new(i), basic_block);
-        }
-    }
-}
-
-impl<T: MirPass> MirMapPass for T {
-    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>) {
+impl<'tcx, T: MirPass<'tcx>> MirMapPass<'tcx> for T {
+    fn run_pass(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>) {
         for (_, mir) in &mut map.map {
             MirPass::run_pass(self, tcx, mir);
         }
@@ -56,7 +37,7 @@ impl<T: MirPass> MirMapPass for T {
 
 /// A manager for MIR passes.
 pub struct Passes {
-    passes: Vec<Box<MirMapPass>>
+    passes: Vec<Box<for<'tcx> MirMapPass<'tcx>>>
 }
 
 impl Passes {
@@ -68,19 +49,18 @@ impl Passes {
     }
 
     pub fn run_passes<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>) {
-        self.passes.sort_by_key(|e| e.priority());
         for pass in &mut self.passes {
             pass.run_pass(tcx, map);
         }
     }
 
-    pub fn push_pass(&mut self, pass: Box<MirMapPass>) {
+    pub fn push_pass(&mut self, pass: Box<for<'a> MirMapPass<'a>>) {
         self.passes.push(pass);
     }
 }
 
-impl ::std::iter::Extend<Box<MirMapPass>> for Passes {
-    fn extend<I: IntoIterator<Item=Box<MirMapPass>>>(&mut self, it: I) {
+impl ::std::iter::Extend<Box<for<'a> MirMapPass<'a>>> for Passes {
+    fn extend<I: IntoIterator<Item=Box<for <'a> MirMapPass<'a>>>>(&mut self, it: I) {
         self.passes.extend(it);
     }
 }

src/librustc_mir/transform/erase_regions.rs

@@ -28,19 +28,14 @@ pub fn erase_regions<'tcx>(tcx: &ty::ctxt<'tcx>, mir_map: &mut MirMap<'tcx>) {
 
 pub struct EraseRegions;
 
-impl MirPass for EraseRegions {
-    fn run_pass<'tcx>(&mut self, tcx: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+impl<'tcx> MirPass<'tcx> for EraseRegions {
+    fn run_pass(&mut self, tcx: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
         EraseRegionsVisitor::new(tcx).visit_mir(mir);
     }
 
 }
 
 impl Pass for EraseRegions {
-    fn priority(&self) -> usize {
-        // We want this pass to run as late as possible in transformation chain, so we give it a
-        // very high priority number.
-        !50
-    }
 }
 
 struct EraseRegionsVisitor<'a, 'tcx: 'a> {

src/librustc_mir/transform/print.rs

@@ -28,14 +28,10 @@ use std::fs::File;
 pub struct MirPrint;
 
 impl Pass for MirPrint {
-    fn priority(&self) -> usize {
-        // This is a late pass, because we usually want to see the Mir post-passes.
-        !100
-    }
 }
 
-impl MirMapPass for MirPrint {
-    fn run_pass<'tcx>(&mut self, tcx: &ty::ctxt<'tcx>, map: &mut MirMap<'tcx>) {
+impl<'tcx> MirMapPass<'tcx> for MirPrint {
+    fn run_pass(&mut self, tcx: &ty::ctxt<'tcx>, map: &mut MirMap<'tcx>) {
         let _task = tcx.map.dep_graph.in_task(DepNode::MirPrintPass);
         for (node_id, mir) in &map.map {
             for attr in tcx.map.attrs(*node_id) {

src/librustc_mir/transform/simplify_cfg.rs

@@ -18,14 +18,11 @@ use rustc::mir::transform::{MirPass, Pass};
 pub struct SimplifyCfg;
 
 impl Pass for SimplifyCfg {
-    fn priority(&self) -> usize {
-        50
-    }
 }
 
-impl MirPass for SimplifyCfg {
-    fn run_pass<'tcx>(&mut self, tcx: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
-        let mut dbr_pass = DeadBlockRemoval::new(self);
+impl<'tcx> MirPass<'tcx> for SimplifyCfg {
+    fn run_pass(&mut self, tcx: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+        let mut dbr_pass = DeadBlockRemoval;
         let mut changed = true;
         while changed {
             changed = self.simplify_branches(mir);
@@ -119,22 +116,13 @@ impl SimplifyCfg {
 ///
 /// You want to schedule this pass just after any pass which might introduce unreachable blocks.
 /// This pass is very cheap and might improve the run-time of other not-so-cheap passes.
-pub struct DeadBlockRemoval(usize);
-
-impl DeadBlockRemoval {
-    fn new(run_after: &Pass) -> DeadBlockRemoval {
-        DeadBlockRemoval(run_after.priority() + 1)
-    }
-}
+pub struct DeadBlockRemoval;
 
 impl Pass for DeadBlockRemoval {
-    fn priority(&self) -> usize {
-        self.0
-    }
 }
 
-impl MirPass for DeadBlockRemoval {
-    fn run_pass<'tcx>(&mut self, _: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+impl<'tcx> MirPass<'tcx> for DeadBlockRemoval {
+    fn run_pass(&mut self, _: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
         let mut seen = vec![false; mir.basic_blocks.len()];
 
         // These blocks are always required.
@@ -159,14 +147,10 @@ impl MirPass for DeadBlockRemoval {
 pub struct CompactMir;
 
 impl Pass for CompactMir {
-    fn priority(&self) -> usize {
-        // We want this pass to run very late, so we give it a very high priority number.
-        !10
-    }
 }
 
-impl MirPass for CompactMir {
-    fn run_pass<'tcx>(&mut self, _: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+impl<'tcx> MirPass<'tcx> for CompactMir {
+    fn run_pass(&mut self, _: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
         self.visit_mir(mir);
     }
 }

src/librustc_plugin/registry.rs

@@ -56,7 +56,7 @@ pub struct Registry<'a> {
     pub late_lint_passes: Vec<LateLintPassObject>,
 
     #[doc(hidden)]
-    pub mir_passes: Vec<Box<mir::transform::MirMapPass>>,
+    pub mir_passes: Vec<Box<for<'p> mir::transform::MirMapPass<'p>>>,
 
     #[doc(hidden)]
     pub lint_groups: HashMap<&'static str, Vec<LintId>>,
@@ -141,7 +141,7 @@ impl<'a> Registry<'a> {
     }
 
     /// Register a MIR pass
-    pub fn register_mir_pass(&mut self, pass: Box<mir::transform::MirMapPass>) {
+    pub fn register_mir_pass(&mut self, pass: Box<for<'p> mir::transform::MirMapPass<'p>>) {
         self.mir_passes.push(pass);
     }