convert the inline pass to use the new multi result

This involves changing various details about that system,
though the basic shape remains the same.

Author: nikomatsakis

src/librustc/mir/transform.rs

@@ -13,6 +13,8 @@ use hir::def_id::DefId;
 use hir::map::DefPathData;
 use mir::{Mir, Promoted};
 use ty::TyCtxt;
+use ty::maps::Multi;
+use ty::steal::Steal;
 use std::cell::Ref;
 use std::rc::Rc;
 use syntax::ast::NodeId;
@@ -70,15 +72,6 @@ impl<'a, 'tcx> MirSource {
     }
 }
 
-/// Various information about pass.
-pub trait Pass {
-    fn name<'a>(&'a self) -> Cow<'a, str> {
-        default_name::<Self>()
-    }
-
-    fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>);
-}
-
 /// Generates a default name for the pass based on the name of the
 /// type `T`.
 pub fn default_name<T: ?Sized>() -> Cow<'static, str> {
@@ -97,8 +90,20 @@ pub trait MirCtxt<'a, 'tcx: 'a> {
     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)]
@@ -116,17 +121,35 @@ pub struct MirPassIndex(pub usize);
 /// `mir_cx.read_previous_mir()`); after the pass executes, it will be
 /// `Some()` with the result of the pass (in which case the output
 /// from the previous pass is most likely stolen, so you would not
-/// want to try and access it).
+/// want to try and access it). If the pass is interprocedural, then
+/// 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<&Mir<'tcx>>);
+                                 mir: Option<(DefId, &Mir<'tcx>)>);
 }
 
-/// A streamlined trait that you can implement to create a 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`.
+/// The full suite of types that identifies a particular
+/// application of a pass to a def-id.
+pub type PassId = (MirSuite, MirPassIndex, DefId);
+
+/// The most generic sort of MIR pass. You only want to implement this
+/// rather general trait if you are doing an interprocedural pass that
+/// may inspect and affect the MIR of many def-ids. Otherwise, prefer
+/// the more steamlined `DefIdPass` or `MirPass`.
+pub trait Pass {
+    fn name<'a>(&'a self) -> Cow<'a, str> {
+        default_name::<Self>()
+    }
+
+    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>)
+                              -> Multi<PassId, &'tcx Steal<Mir<'tcx>>>;
+}
+
+/// 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>()
@@ -135,10 +158,21 @@ pub trait DefIdPass {
     fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>) -> Mir<'tcx>;
 }
 
+impl<T: DefIdPass> Pass for T {
+    fn name<'a>(&'a self) -> Cow<'a, str> {
+        DefIdPass::name(self)
+    }
+
+    fn run_pass<'a, 'tcx: 'a>(&self, mir_cx: &MirCtxt<'a, 'tcx>)
+                              -> Multi<PassId, &'tcx Steal<Mir<'tcx>>> {
+        Multi::from(mir_cx.tcx().alloc_steal_mir(DefIdPass::run_pass(self, mir_cx)))
+    }
+}
+
 /// 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`.
-pub trait MirPass: DepGraphSafe {
+pub trait MirPass {
     fn name<'a>(&'a self) -> Cow<'a, str> {
         default_name::<Self>()
     }
@@ -174,7 +208,7 @@ impl<T: MirPass> DefIdPass for T {
 #[derive(Clone)]
 pub struct Passes {
     pass_hooks: Vec<Rc<PassHook>>,
-    suites: Vec<Vec<Rc<DefIdPass>>>,
+    suites: Vec<Vec<Rc<Pass>>>,
 }
 
 /// The number of "pass suites" that we have:
@@ -202,7 +236,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: Pass + 'static>(&mut self, suite: MirSuite, pass: T) {
         self.suites[suite.0].push(Rc::new(pass));
     }
 
@@ -215,7 +249,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) -> &Pass {
         &*self.suites[suite.0][pass.0]
     }
 

src/librustc/ty/maps.rs

@@ -24,20 +24,21 @@ use ty::steal::Steal;
 use ty::subst::Substs;
 use util::nodemap::{DefIdSet, NodeSet};
 
-use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::IndexVec;
 use std::cell::{RefCell, RefMut};
+use std::option;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::iter::{self, Once};
 use std::mem;
 use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::rc::Rc;
+use std::vec;
 use syntax_pos::{Span, DUMMY_SP};
 use syntax::symbol::Symbol;
 
-trait Key: Clone + Hash + Eq + Debug {
+pub trait Key: Clone + Hash + Eq + Debug {
     fn map_crate(&self) -> CrateNum;
     fn default_span(&self, tcx: TyCtxt) -> Span;
 }
@@ -163,27 +164,61 @@ impl<'tcx> Value<'tcx> for ty::SymbolName {
 trait IntoKeyValues<K: Key, V> {
     type KeyValues: IntoIterator<Item=(K, V)>;
 
-    fn into_key_values(tcx: TyCtxt, key: &K, value: Self) -> Self::KeyValues;
+    fn into_key_values(key: &K, value: Self) -> Self::KeyValues;
 }
 
 impl<K: Key, V> IntoKeyValues<K, V> for V {
     type KeyValues = Once<(K, V)>;
 
-    fn into_key_values(_: TyCtxt, key: &K, value: Self) -> Self::KeyValues {
+    fn into_key_values(key: &K, value: Self) -> Self::KeyValues {
         iter::once((key.clone(), value))
     }
 }
 
-impl<K: Key, V> IntoKeyValues<K, V> for FxHashMap<K, V> {
-    type KeyValues = Self;
+/// Return type for a multi-query, which is a query which may (if it
+/// chooses) return more than one (key, value) pair. Construct a
+/// `Multi` using `Multi::from(...)`.
+pub struct Multi<K: Key, V> {
+    single: Option<V>,
+    map: Vec<(K, V)>,
+}
 
-    fn into_key_values(tcx: TyCtxt, key: &K, value: Self) -> Self {
-        if !value.contains_key(key) {
-            span_bug!(key.default_span(tcx),
-                      "multi-generation function for `{:?}` did not generate a value for `{:?}`",
-                      key, key)
+impl<K: Key, V> Multi<K, V> {
+    pub fn iter<'a>(&'a self, key: &'a K) -> impl Iterator<Item = (&'a K, &'a V)> + 'a {
+        self.single.iter()
+                   .map(move |v| (key, v))
+                   .chain(self.map.iter().map(move |&(ref k, ref v)| (k, v)))
+    }
+}
+
+/// Construct a `Multi` from a single value.
+impl<K: Key, V> From<V> for Multi<K, V> {
+    fn from(value: V) -> Self {
+        Multi {
+            single: Some(value),
+            map: vec![],
         }
-        value
+    }
+}
+
+/// Construct a `Multi` from a hashmap of (K, V) pairs.
+impl<K: Key, V> From<Vec<(K, V)>> for Multi<K, V> {
+    fn from(value: Vec<(K, V)>) -> Self {
+        Multi {
+            single: None,
+            map: value
+        }
+    }
+}
+
+impl<K: Key, V> IntoKeyValues<K, V> for Multi<K, V> {
+    type KeyValues = iter::Chain<option::IntoIter<(K, V)>, vec::IntoIter<(K, V)>>;
+
+    fn into_key_values(key: &K, value: Self) -> Self::KeyValues {
+        value.single
+             .map(|v| (key.clone(), v))
+             .into_iter()
+             .chain(value.map)
     }
 }
 
@@ -469,7 +504,7 @@ macro_rules! define_maps {
 
                 {
                     let map = &mut *tcx.maps.$name.borrow_mut();
-                    for (k, v) in IntoKeyValues::<$K, $V>::into_key_values(tcx, &key, result) {
+                    for (k, v) in IntoKeyValues::<$K, $V>::into_key_values(&key, result) {
                         map.insert(k, v);
                     }
                 }
@@ -545,16 +580,6 @@ macro_rules! define_maps {
         impl<$tcx> Clone for Providers<$tcx> {
             fn clone(&self) -> Self { *self }
         }
-
-        impl<$tcx> Default for Providers<$tcx> {
-            fn default() -> Self {
-                $(fn $name<'a, $tcx>(_: TyCtxt<'a, $tcx, $tcx>, key: $K) -> $V {
-                    bug!("tcx.maps.{}({:?}) unsupported by its crate",
-                         stringify!($name), key);
-                })*
-                Providers { $($name),* }
-            }
-        }
     }
 }
 
@@ -642,34 +667,43 @@ macro_rules! define_provider_struct {
     // Final state:
     (tcx: $tcx:tt,
      input: (),
-     output: ($($output:tt)*)) => {
+     output: ($(([$name:ident] [$K:ty] [$R:ty]))*)) => {
         pub struct Providers<$tcx> {
-            $($output)*
+            $(pub $name: for<'a> fn(TyCtxt<'a, $tcx, $tcx>, $K) -> $R,)*
+        }
+
+        impl<$tcx> Default for Providers<$tcx> {
+            fn default() -> Self {
+                $(fn $name<'a, $tcx>(_: TyCtxt<'a, $tcx, $tcx>, key: $K) -> $R {
+                    bug!("tcx.maps.{}({:?}) unsupported by its crate",
+                         stringify!($name), key);
+                })*
+                Providers { $($name),* }
+            }
         }
     };
 
     // Something ready to shift:
     (tcx: $tcx:tt,
-     ready: ([$name:ident] [$K:ty] [$R:ty]),
+     ready: ($name:tt $K:tt $V:tt),
      input: $input:tt,
      output: ($($output:tt)*)) => {
         define_provider_struct! {
             tcx: $tcx,
             input: $input,
-            output: ($($output)*
-                     pub $name: for<'a> fn(TyCtxt<'a, $tcx, $tcx>, $K) -> $R,)
+            output: ($($output)* ($name $K $V))
         }
     };
 
     // The `multi` modifier indicates a **multiquery**, in which case
-    // the function returns a `FxHashMap<K,V>` instead of just a value
+    // the function returns a `Multi<K,V>` instead of just a value
     // `V`.
     (tcx: $tcx:tt,
      input: (([multi $($other_modifiers:tt)*] $name:tt [$K:ty] [$V:ty]) $($input:tt)*),
      output: $output:tt) => {
         define_provider_struct! {
             tcx: $tcx,
-            ready: ($name [$K] [FxHashMap<$K,$V>]),
+            ready: ($name [$K] [Multi<$K,$V>]),
             input: ($($input)*),
             output: $output
         }
@@ -778,7 +812,7 @@ define_maps! { <'tcx>
     /// Fetch the MIR for a given def-id after a given pass has been executed. This is
     /// **only** intended to be used by the `mir_suite` provider -- if you are using it
     /// manually, you're doing it wrong.
-    [] mir_pass: mir_pass((MirSuite, MirPassIndex, DefId)) -> &'tcx Steal<mir::Mir<'tcx>>,
+    [multi] 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_driver/driver.rs

@@ -929,7 +929,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
     passes.push_pass(MIR_OPTIMIZED, mir::transform::simplify::SimplifyCfg::new("elaborate-drops"));
 
     // No lifetime analysis based on borrowing can be done from here on out.
-    // passes.push_pass(MIR_OPTIMIZED, mir::transform::inline::Inline); // TODO re-enable
+    passes.push_pass(MIR_OPTIMIZED, mir::transform::inline::Inline);
     passes.push_pass(MIR_OPTIMIZED, mir::transform::instcombine::InstCombine);
     passes.push_pass(MIR_OPTIMIZED, mir::transform::deaggregator::Deaggregator);
     passes.push_pass(MIR_OPTIMIZED, mir::transform::copy_prop::CopyPropagation);

src/librustc_mir/callgraph.rs

@@ -22,30 +22,31 @@ use rustc::ty;
 
 use rustc::util::nodemap::DefIdMap;
 
+use transform::interprocedural::InterproceduralCx;
+
 pub struct CallGraph {
     node_map: DefIdMap<graph::NodeIndex>,
     graph: graph::Graph<DefId, ()>
 }
 
 impl CallGraph {
-    // FIXME: allow for construction of a callgraph that inspects
-    // cross-crate MIRs if available.
-    pub fn build<'a, 'tcx>(tcx: ty::TyCtxt<'a, 'tcx, 'tcx>) -> CallGraph {
+    pub fn build<'a, 'mir, 'tcx>(cx: &mut InterproceduralCx<'a, 'mir, 'tcx>) -> CallGraph {
         let mut callgraph = CallGraph {
             node_map: DefIdMap(),
             graph: graph::Graph::new()
         };
 
-        for &def_id in tcx.mir_keys(LOCAL_CRATE).iter() {
+        for &def_id in cx.tcx.mir_keys(LOCAL_CRATE).iter() {
             let idx = callgraph.add_node(def_id);
 
             let mut call_visitor = CallVisitor {
                 caller: idx,
                 graph: &mut callgraph
             };
 
-            let mir = tcx.item_mir(def_id);
-            call_visitor.visit_mir(&mir);
+            if let Some(mir) = cx.ensure_mir_and_read(def_id) {
+                call_visitor.visit_mir(mir);
+            }
         }
 
         callgraph