rip out everything but MirPass, move the logic into suites

Author: nikomatsakis

src/librustc/mir/transform.rs

@@ -15,7 +15,6 @@ use hir::def_id::DefId;
 use hir::map::DefPathData;
 use mir::{Mir, Promoted};
 use ty::TyCtxt;
-use std::cell::Ref;
 use std::rc::Rc;
 use syntax::ast::NodeId;
 
@@ -83,29 +82,6 @@ pub fn default_name<T: ?Sized>() -> Cow<'static, str> {
     }
 }
 
-/// Gives you access to various bits of state during your MIR pass.
-pub trait MirCtxt<'a, 'tcx: 'a> {
-    fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx>;
-    fn def_id(&self) -> DefId;
-    fn suite(&self) -> MirSuite;
-    fn pass_num(&self) -> MirPassIndex;
-    fn source(&self) -> MirSource;
-
-    // Get a read-only view on the MIR of this def-id from the
-    // previous pass.
-    fn read_previous_mir(&self) -> Ref<'tcx, Mir<'tcx>>;
-
-    // Steal the MIR of this def-id from the previous pass; any future
-    // attempt to access the MIR from the previous pass is a bug.
-    fn steal_previous_mir(&self) -> Mir<'tcx>;
-
-    // Same as `read_previous_mir()`, but for any def-id you want.
-    fn read_previous_mir_of(&self, def_id: DefId) -> Ref<'tcx, Mir<'tcx>>;
-
-    // Same as `steal_previous_mir()`, but for any def-id you want.
-    fn steal_previous_mir_of(&self, def_id: DefId) -> Mir<'tcx>;
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct MirSuite(pub usize);
 
@@ -125,26 +101,19 @@ pub struct MirPassIndex(pub usize);
 /// the hook will be invoked once per output.
 pub trait PassHook {
     fn on_mir_pass<'a, 'tcx: 'a>(&self,
-                                 mir_cx: &MirCtxt<'a, 'tcx>,
-                                 mir: Option<(DefId, &Mir<'tcx>)>);
+                                 tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                 suite: MirSuite,
+                                 pass_num: MirPassIndex,
+                                 pass_name: &str,
+                                 source: MirSource,
+                                 mir: &Mir<'tcx>,
+                                 is_after: bool);
 }
 
 /// The full suite of types that identifies a particular
 /// application of a pass to a def-id.
 pub type PassId = (MirSuite, MirPassIndex, DefId);
 
-/// A streamlined trait that you can implement to create an
-/// intraprocedural pass; the pass will be invoked to process the MIR
-/// with the given `def_id`.  This lets you do things before we fetch
-/// the MIR itself. You may prefer `MirPass`, which is even more streamlined.
-pub trait DefIdPass {
-    fn name<'a>(&'a self) -> Cow<'a, str> {
-        default_name::<Self>()
-    }
-
-    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>) -> Mir<'tcx>;
-}
-
 /// A streamlined trait that you can implement to create a pass; the
 /// pass will be named after the type, and it will consist of a main
 /// loop that goes over each available MIR and applies `run_pass`.
@@ -159,32 +128,11 @@ pub trait MirPass {
                           mir: &mut Mir<'tcx>);
 }
 
-impl<T: MirPass> DefIdPass for T {
-    fn name<'a>(&'a self) -> Cow<'a, str> {
-        MirPass::name(self)
-    }
-
-    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>) -> Mir<'tcx> {
-        let tcx = mir_cx.tcx();
-        let source = mir_cx.source();
-        let mut mir = mir_cx.steal_previous_mir();
-        MirPass::run_pass(self, tcx, source, &mut mir);
-
-        let item_id = source.item_id();
-        for (promoted_index, promoted_mir) in mir.promoted.iter_enumerated_mut() {
-            let promoted_source = MirSource::Promoted(item_id, promoted_index);
-            MirPass::run_pass(self, tcx, promoted_source, promoted_mir);
-        }
-
-        mir
-    }
-}
-
 /// A manager for MIR passes.
 #[derive(Clone)]
 pub struct Passes {
     pass_hooks: Vec<Rc<PassHook>>,
-    suites: Vec<Vec<Rc<DefIdPass>>>,
+    suites: Vec<Vec<Rc<MirPass>>>,
 }
 
 /// The number of "pass suites" that we have:
@@ -212,7 +160,7 @@ impl<'a, 'tcx> Passes {
     }
 
     /// Pushes a built-in pass.
-    pub fn push_pass<T: DefIdPass + 'static>(&mut self, suite: MirSuite, pass: T) {
+    pub fn push_pass<T: MirPass + 'static>(&mut self, suite: MirSuite, pass: T) {
         self.suites[suite.0].push(Rc::new(pass));
     }
 
@@ -225,7 +173,7 @@ impl<'a, 'tcx> Passes {
         self.suites[suite.0].len()
     }
 
-    pub fn pass(&self, suite: MirSuite, pass: MirPassIndex) -> &DefIdPass {
+    pub fn pass(&self, suite: MirSuite, pass: MirPassIndex) -> &MirPass {
         &*self.suites[suite.0][pass.0]
     }
 

src/librustc/ty/maps.rs

@@ -818,7 +818,7 @@ define_maps! { <'tcx>
     /// manually, you're doing it wrong.
     ///
     /// See the README for the `mir` module for details.
-    [multi] mir_pass: mir_pass((MirSuite, MirPassIndex, DefId)) -> &'tcx Steal<mir::Mir<'tcx>>,
+    [] mir_pass: mir_pass((MirSuite, MirPassIndex, DefId)) -> &'tcx Steal<mir::Mir<'tcx>>,
 
     /// MIR after our optimization passes have run. This is MIR that is ready
     /// for trans. This is also the only query that can fetch non-local MIR, at present.

src/librustc_mir/callgraph.rs

@@ -30,7 +30,7 @@ pub struct CallGraph {
 }
 
 impl CallGraph {
-    pub fn build<'a, 'mir, 'tcx>(cx: &mut InterproceduralCx<'a, 'mir, 'tcx>) -> CallGraph {
+    pub fn build<'a, 'tcx>(cx: &mut InterproceduralCx<'a, 'tcx>) -> CallGraph {
         let mut callgraph = CallGraph {
             node_map: DefIdMap(),
             graph: graph::Graph::new()

src/librustc_mir/transform/dump_mir.rs

@@ -15,22 +15,24 @@ use std::fmt;
 use std::fs::File;
 use std::io;
 
-use rustc::hir::def_id::DefId;
 use rustc::mir::Mir;
-use rustc::mir::transform::{DefIdPass, MirCtxt, MirSource, PassHook};
+use rustc::mir::transform::{MirPass, MirPassIndex, MirSource, MirSuite, PassHook};
 use rustc::session::config::{OutputFilenames, OutputType};
 use rustc::ty::TyCtxt;
 use util as mir_util;
 
 pub struct Marker(pub &'static str);
 
-impl DefIdPass for Marker {
+impl MirPass for Marker {
     fn name<'a>(&'a self) -> Cow<'a, str> {
         Cow::Borrowed(self.0)
     }
 
-    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>) -> Mir<'tcx> {
-        mir_cx.steal_previous_mir()
+    fn run_pass<'a, 'tcx>(&self,
+                          _tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                          _source: MirSource,
+                          _mir: &mut Mir<'tcx>)
+    {
     }
 }
 
@@ -49,37 +51,21 @@ pub struct DumpMir;
 
 impl PassHook for DumpMir {
     fn on_mir_pass<'a, 'tcx: 'a>(&self,
-                                 mir_cx: &MirCtxt<'a, 'tcx>,
-                                 mir: Option<(DefId, &Mir<'tcx>)>)
+                                 tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                 suite: MirSuite,
+                                 pass_num: MirPassIndex,
+                                 pass_name: &str,
+                                 source: MirSource,
+                                 mir: &Mir<'tcx>,
+                                 is_after: bool)
     {
-        let tcx = mir_cx.tcx();
-        let suite = mir_cx.suite();
-        let pass_num = mir_cx.pass_num();
-        let pass = tcx.mir_passes.pass(suite, pass_num);
-        let name = &pass.name();
-        let source = match mir {
-            None => mir_cx.source(),
-            Some((def_id, _)) => {
-                let id = tcx.hir.as_local_node_id(def_id)
-                                .expect("mir source requires local def-id");
-                MirSource::from_node(tcx, id)
-            }
-        };
-        if mir_util::dump_enabled(tcx, name, source) {
-            let previous_mir;
-            let mir_to_dump = match mir {
-                Some((_, m)) => m,
-                None => {
-                    previous_mir = mir_cx.read_previous_mir();
-                    &*previous_mir
-                }
-            };
+        if mir_util::dump_enabled(tcx, pass_name, source) {
             mir_util::dump_mir(tcx,
                                Some((suite, pass_num)),
-                               name,
-                               &Disambiguator { is_after: mir.is_some() },
+                               pass_name,
+                               &Disambiguator { is_after },
                                source,
-                               mir_to_dump);
+                               mir);
         }
     }
 }

src/librustc_mir/transform/inline.rs

@@ -18,7 +18,7 @@ use rustc_data_structures::graph;
 
 use rustc::dep_graph::DepNode;
 use rustc::mir::*;
-use rustc::mir::transform::{MirCtxt, MirSource, PassId};
+use rustc::mir::transform::{MirSource, PassId};
 use rustc::mir::visit::*;
 use rustc::traits;
 use rustc::ty::{self, Ty, TyCtxt};
@@ -46,19 +46,14 @@ const UNKNOWN_SIZE_COST: usize = 10;
 pub struct Inline;
 
 pub trait Pass {
-    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>)
+    fn run_pass<'a, 'tcx: 'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>)
                               -> Multi<PassId, &'tcx Steal<Mir<'tcx>>>;
 }
 
 impl Pass for Inline {
-    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>)
+    fn run_pass<'a, 'tcx: 'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>)
                               -> Multi<PassId, &'tcx Steal<Mir<'tcx>>> {
-        let tcx = mir_cx.tcx();
-        if tcx.sess.opts.debugging_opts.mir_opt_level < 2 {
-            return Multi::from(tcx.alloc_steal_mir(mir_cx.steal_previous_mir()));
-        }
-
-        let mut cx = InterproceduralCx::new(mir_cx);
+        let mut cx = InterproceduralCx::new(tcx);
 
         let callgraph = callgraph::CallGraph::build(&mut cx);
 
@@ -72,8 +67,8 @@ impl Pass for Inline {
     }
 }
 
-struct Inliner<'mir, 'tcx: 'mir> {
-    tcx: TyCtxt<'mir, 'tcx, 'tcx>,
+struct Inliner<'a, 'tcx: 'a> {
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 #[derive(Copy, Clone)]
@@ -85,11 +80,11 @@ struct CallSite<'tcx> {
     location: SourceInfo,
 }
 
-impl<'mir, 'tcx> Inliner<'mir, 'tcx> {
-    fn inline_scc<'a>(&mut self,
-                      cx: &mut InterproceduralCx<'a, 'mir, 'tcx>,
-                      callgraph: &callgraph::CallGraph,
-                      scc: &[graph::NodeIndex]) -> bool {
+impl<'a, 'tcx> Inliner<'a, 'tcx> {
+    fn inline_scc(&mut self,
+                  cx: &mut InterproceduralCx<'a, 'tcx>,
+                  callgraph: &callgraph::CallGraph,
+                  scc: &[graph::NodeIndex]) -> bool {
         let tcx = self.tcx;
         let mut callsites = Vec::new();
         let mut in_scc = DefIdSet();

src/librustc_mir/transform/interprocedural.rs

@@ -10,7 +10,7 @@
 
 use rustc::hir::def_id::DefId;
 use rustc::mir::Mir;
-use rustc::mir::transform::{MirCtxt, PassId};
+use rustc::mir::transform::{PassId};
 use rustc::ty::steal::Steal;
 use rustc::ty::TyCtxt;
 use rustc_data_structures::fx::FxHashMap;
@@ -21,31 +21,21 @@ use rustc_data_structures::fx::FxHashMap;
 /// stolen and so forth. It is more of a placeholder meant to get
 /// inlining up and going again, and is probably going to need heavy
 /// revision as we scale up to more interesting optimizations.
-pub struct InterproceduralCx<'a, 'mir: 'a, 'tcx: 'mir> {
-    pub tcx: TyCtxt<'mir, 'tcx, 'tcx>,
-    pub mir_cx: &'a MirCtxt<'mir, 'tcx>,
+pub struct InterproceduralCx<'a, 'tcx: 'a> {
+    pub tcx: TyCtxt<'a, 'tcx, 'tcx>,
     local_cache: FxHashMap<DefId, Mir<'tcx>>,
 }
 
-impl<'a, 'mir, 'tcx> InterproceduralCx<'a, 'mir, 'tcx> {
-    pub fn new(mir_cx: &'a MirCtxt<'mir, 'tcx>) -> Self {
+impl<'a, 'tcx> InterproceduralCx<'a, 'tcx> {
+    pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
         InterproceduralCx {
-            mir_cx,
-            tcx: mir_cx.tcx(),
+            tcx: tcx,
             local_cache: FxHashMap::default(),
         }
     }
 
     pub fn into_local_mirs(self) -> Vec<(PassId, &'tcx Steal<Mir<'tcx>>)> {
-        let tcx = self.tcx;
-        let suite = self.mir_cx.suite();
-        let pass_num = self.mir_cx.pass_num();
-        self.local_cache.into_iter()
-                        .map(|(def_id, mir)| {
-                            let mir = tcx.alloc_steal_mir(mir);
-                            ((suite, pass_num, def_id), mir)
-                        })
-                        .collect()
+        unimplemented!()
     }
 
     /// Ensures that the mir for `def_id` is available, if it can be
@@ -93,8 +83,6 @@ impl<'a, 'mir, 'tcx> InterproceduralCx<'a, 'mir, 'tcx> {
 
     pub fn mir_mut(&mut self, def_id: DefId) -> &mut Mir<'tcx> {
         assert!(def_id.is_local(), "cannot get mutable mir of remote entry");
-        let mir_cx = self.mir_cx;
-        self.local_cache.entry(def_id)
-                        .or_insert_with(|| mir_cx.steal_previous_mir_of(def_id))
+        unimplemented!()
     }
 }