mir: prepare for rvalue promotion support.

Author: eddyb

src/librustc/dep_graph/dep_node.rs

@@ -64,6 +64,7 @@ pub enum DepNode<D: Clone + Debug> {
     IntrinsicCheck(D),
     MatchCheck(D),
     MirMapConstruction(D),
+    MirPass(D),
     MirTypeck(D),
     BorrowCheck(D),
     RvalueCheck(D),
@@ -186,6 +187,7 @@ impl<D: Clone + Debug> DepNode<D> {
             IntrinsicCheck(ref d) => op(d).map(IntrinsicCheck),
             MatchCheck(ref d) => op(d).map(MatchCheck),
             MirMapConstruction(ref d) => op(d).map(MirMapConstruction),
+            MirPass(ref d) => op(d).map(MirPass),
             MirTypeck(ref d) => op(d).map(MirTypeck),
             BorrowCheck(ref d) => op(d).map(BorrowCheck),
             RvalueCheck(ref d) => op(d).map(RvalueCheck),

src/librustc/mir/repr.rs

@@ -36,6 +36,11 @@ pub struct Mir<'tcx> {
     /// used (eventually) for debuginfo. Indexed by a `ScopeId`.
     pub scopes: Vec<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: Vec<Mir<'tcx>>,
+
     /// Return type of the function.
     pub return_ty: FnOutput<'tcx>,
 
@@ -987,6 +992,10 @@ pub enum Literal<'tcx> {
     Value {
         value: ConstVal,
     },
+    Promoted {
+        // Index into the `promoted` vector of `Mir`.
+        index: usize
+    },
 }
 
 impl<'tcx> Debug for Constant<'tcx> {
@@ -1007,6 +1016,9 @@ impl<'tcx> Debug for Literal<'tcx> {
                 write!(fmt, "const ")?;
                 fmt_const_val(fmt, value)
             }
+            Promoted { index } => {
+                write!(fmt, "promoted{}", index)
+            }
         }
     }
 }

src/librustc/mir/transform.rs

@@ -8,31 +8,102 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use dep_graph::DepNode;
+use hir;
+use hir::map::DefPathData;
+use hir::def_id::DefId;
 use mir::mir_map::MirMap;
 use mir::repr::Mir;
 use ty::TyCtxt;
 use syntax::ast::NodeId;
 
+/// Where a specific Mir comes from.
+#[derive(Copy, Clone)]
+pub enum MirSource {
+    /// Functions and methods.
+    Fn(NodeId),
+
+    /// Constants and associated constants.
+    Const(NodeId),
+
+    /// Initializer of a `static` item.
+    Static(NodeId, hir::Mutability),
+
+    /// Promoted rvalues within a function.
+    Promoted(NodeId, usize)
+}
+
+impl MirSource {
+    pub fn from_node(tcx: &TyCtxt, id: NodeId) -> MirSource {
+        use hir::*;
+
+        // Handle constants in enum discriminants, types, and repeat expressions.
+        let def_id = tcx.map.local_def_id(id);
+        let def_key = tcx.def_key(def_id);
+        if def_key.disambiguated_data.data == DefPathData::Initializer {
+            return MirSource::Const(id);
+        }
+
+        match tcx.map.get(id) {
+            map::NodeItem(&Item { node: ItemConst(..), .. }) |
+            map::NodeTraitItem(&TraitItem { node: ConstTraitItem(..), .. }) |
+            map::NodeImplItem(&ImplItem { node: ImplItemKind::Const(..), .. }) => {
+                MirSource::Const(id)
+            }
+            map::NodeItem(&Item { node: ItemStatic(_, m, _), .. }) => {
+                MirSource::Static(id, m)
+            }
+            // Default to function if it's not a constant or static.
+            _ => MirSource::Fn(id)
+        }
+    }
+
+    pub fn item_id(&self) -> NodeId {
+        match *self {
+            MirSource::Fn(id) |
+            MirSource::Const(id) |
+            MirSource::Static(id, _) |
+            MirSource::Promoted(id, _) => id
+        }
+    }
+}
+
 /// Various information about pass.
 pub trait Pass {
     // fn name() for printouts of various sorts?
     // fn should_run(Session) to check if pass should run?
+    fn dep_node(&self, def_id: DefId) -> DepNode<DefId> {
+        DepNode::MirPass(def_id)
+    }
 }
 
 /// A pass which inspects the whole MirMap.
 pub trait MirMapPass<'tcx>: Pass {
-    fn run_pass(&mut self, cx: &TyCtxt<'tcx>, map: &mut MirMap<'tcx>);
+    fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, map: &mut MirMap<'tcx>);
 }
 
 /// A pass which inspects Mir of functions in isolation.
 pub trait MirPass<'tcx>: Pass {
-    fn run_pass(&mut self, cx: &TyCtxt<'tcx>, id: NodeId, mir: &mut Mir<'tcx>);
+    fn run_pass_on_promoted(&mut self, tcx: &TyCtxt<'tcx>,
+                            item_id: NodeId, index: usize,
+                            mir: &mut Mir<'tcx>) {
+        self.run_pass(tcx, MirSource::Promoted(item_id, index), mir);
+    }
+    fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, src: MirSource, mir: &mut Mir<'tcx>);
 }
 
 impl<'tcx, T: MirPass<'tcx>> MirMapPass<'tcx> for T {
     fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, map: &mut MirMap<'tcx>) {
         for (&id, mir) in &mut map.map {
-            MirPass::run_pass(self, tcx, id, mir);
+            let def_id = tcx.map.local_def_id(id);
+            let _task = tcx.dep_graph.in_task(self.dep_node(def_id));
+
+            let src = MirSource::from_node(tcx, id);
+            MirPass::run_pass(self, tcx, src, mir);
+
+            for (i, mir) in mir.promoted.iter_mut().enumerate() {
+                self.run_pass_on_promoted(tcx, id, i, mir);
+            }
         }
     }
 }

src/librustc/mir/visit.rs

@@ -244,6 +244,7 @@ macro_rules! make_mir_visitor {
                 let Mir {
                     ref $($mutability)* basic_blocks,
                     ref $($mutability)* scopes,
+                    promoted: _, // Visited by passes separately.
                     ref $($mutability)* return_ty,
                     ref $($mutability)* var_decls,
                     ref $($mutability)* arg_decls,
@@ -649,10 +650,11 @@ macro_rules! make_mir_visitor {
                                     ref $($mutability)* substs } => {
                         self.visit_def_id(def_id);
                         self.visit_substs(substs);
-                    },
+                    }
                     Literal::Value { ref $($mutability)* value } => {
                         self.visit_const_val(value);
                     }
+                    Literal::Promoted { index: _ } => {}
                 }
             }
 

src/librustc_metadata/decoder.rs

@@ -855,6 +855,9 @@ pub fn maybe_get_item_mir<'tcx>(cdata: Cmd,
         };
 
         def_id_and_span_translator.visit_mir(&mut mir);
+        for promoted in &mut mir.promoted {
+            def_id_and_span_translator.visit_mir(promoted);
+        }
 
         mir
     });

src/librustc_mir/build/mod.rs

@@ -296,6 +296,7 @@ impl<'a,'tcx> Builder<'a,'tcx> {
         (Mir {
             basic_blocks: self.cfg.basic_blocks,
             scopes: self.scope_datas,
+            promoted: vec![],
             var_decls: self.var_decls,
             arg_decls: arg_decls,
             temp_decls: self.temp_decls,

src/librustc_mir/mir_map.rs

@@ -19,6 +19,7 @@
 use build;
 use rustc::dep_graph::DepNode;
 use rustc::mir::repr::Mir;
+use rustc::mir::transform::MirSource;
 use pretty;
 use hair::cx::Cx;
 
@@ -55,20 +56,20 @@ struct BuildMir<'a, 'tcx: 'a> {
 }
 
 impl<'a, 'tcx> BuildMir<'a, 'tcx> {
-    fn build<F>(&mut self, id: ast::NodeId, f: F)
+    fn build<F>(&mut self, src: MirSource, f: F)
         where F: for<'b> FnOnce(Cx<'b, 'tcx>) -> (Mir<'tcx>, build::ScopeAuxiliaryVec)
     {
-        let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
+        let param_env = ty::ParameterEnvironment::for_item(self.tcx, src.item_id());
         let infcx = infer::new_infer_ctxt(self.tcx,
                                           &self.tcx.tables,
                                           Some(param_env),
                                           ProjectionMode::AnyFinal);
 
         let (mir, scope_auxiliary) = f(Cx::new(&infcx));
 
-        pretty::dump_mir(self.tcx, "mir_map", &0, id, &mir, Some(&scope_auxiliary));
+        pretty::dump_mir(self.tcx, "mir_map", &0, src, &mir, Some(&scope_auxiliary));
 
-        assert!(self.map.map.insert(id, mir).is_none())
+        assert!(self.map.map.insert(src.item_id(), mir).is_none())
     }
 
     fn build_const_integer(&mut self, expr: &'tcx hir::Expr) {
@@ -79,17 +80,25 @@ impl<'a, 'tcx> BuildMir<'a, 'tcx> {
         if let hir::ExprClosure(..) = expr.node {
             return;
         }
-        self.build(expr.id, |cx| build::construct_const(cx, expr.id, expr));
+        self.build(MirSource::Const(expr.id), |cx| {
+            build::construct_const(cx, expr.id, expr)
+        });
     }
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for BuildMir<'a, 'tcx> {
     // Const and static items.
     fn visit_item(&mut self, item: &'tcx hir::Item) {
         match item.node {
-            hir::ItemConst(_, ref expr) |
-            hir::ItemStatic(_, _, ref expr) => {
-                self.build(item.id, |cx| build::construct_const(cx, item.id, expr));
+            hir::ItemConst(_, ref expr) => {
+                self.build(MirSource::Const(item.id), |cx| {
+                    build::construct_const(cx, item.id, expr)
+                });
+            }
+            hir::ItemStatic(_, m, ref expr) => {
+                self.build(MirSource::Static(item.id, m), |cx| {
+                    build::construct_const(cx, item.id, expr)
+                });
             }
             _ => {}
         }
@@ -99,15 +108,19 @@ impl<'a, 'tcx> Visitor<'tcx> for BuildMir<'a, 'tcx> {
     // Trait associated const defaults.
     fn visit_trait_item(&mut self, item: &'tcx hir::TraitItem) {
         if let hir::ConstTraitItem(_, Some(ref expr)) = item.node {
-            self.build(item.id, |cx| build::construct_const(cx, item.id, expr));
+            self.build(MirSource::Const(item.id), |cx| {
+                build::construct_const(cx, item.id, expr)
+            });
         }
         intravisit::walk_trait_item(self, item);
     }
 
     // Impl associated const.
     fn visit_impl_item(&mut self, item: &'tcx hir::ImplItem) {
         if let hir::ImplItemKind::Const(_, ref expr) = item.node {
-            self.build(item.id, |cx| build::construct_const(cx, item.id, expr));
+            self.build(MirSource::Const(item.id), |cx| {
+                build::construct_const(cx, item.id, expr)
+            });
         }
         intravisit::walk_impl_item(self, item);
     }
@@ -166,7 +179,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BuildMir<'a, 'tcx> {
                     (fn_sig.inputs[index], Some(&*arg.pat))
                 });
 
-        self.build(id, |cx| {
+        self.build(MirSource::Fn(id), |cx| {
             let arguments = implicit_argument.into_iter().chain(explicit_arguments);
             build::construct_fn(cx, id, arguments, fn_sig.output, body)
         });