Revisions to borrowck::mir to make it easier to call from other contexts

(like (cough)trans(cough)...)

Author: pnkfelix

src/librustc_borrowck/borrowck/mir/dataflow.rs

@@ -171,46 +171,21 @@ impl<'b, 'a: 'b, 'tcx: 'a, BD> MirBorrowckCtxtPreDataflow<'b, 'a, 'tcx, BD>
           BD::Bit: Debug
 {
     fn pre_dataflow_instrumentation(&self, context: &str) -> io::Result<()> {
-        self.if_attr_meta_name_found(
-            "borrowck_graphviz_preflow",
-            |this, path: &str| {
-                let c = format!("{}_preflow", context);
-                graphviz::print_borrowck_graph_to(this, &c, path)
-            })
+        if let Some(ref path) = self.print_preflow_to {
+            let c = format!("{}_preflow", context);
+            graphviz::print_borrowck_graph_to(self, &c, path)
+        } else {
+            Ok(())
+        }
     }
 
     fn post_dataflow_instrumentation(&self, context: &str) -> io::Result<()> {
-        self.if_attr_meta_name_found(
-            "borrowck_graphviz_postflow",
-            |this, path: &str| {
-                let c = format!("{}_postflow", context);
-                graphviz::print_borrowck_graph_to(this, &c, path)
-            })
-    }
-
-    fn if_attr_meta_name_found<F>(&self,
-                                  name: &str,
-                                  callback: F) -> io::Result<()>
-        where F: for <'aa, 'bb> FnOnce(&'aa Self, &'bb str) -> io::Result<()>
-    {
-        for attr in self.attributes {
-            if attr.check_name("rustc_mir") {
-                let items = attr.meta_item_list();
-                for item in items.iter().flat_map(|l| l.iter()) {
-                    if item.check_name(name) {
-                        if let Some(s) = item.value_str() {
-                            return callback(self, &s);
-                        } else {
-                            self.bcx.tcx.sess.span_err(
-                                item.span,
-                                &format!("{} attribute requires a path", item.name()));
-                        }
-                    }
-                }
-            }
+        if let Some(ref path) = self.print_postflow_to {
+            let c = format!("{}_postflow", context);
+            graphviz::print_borrowck_graph_to(self, &c, path)
+        } else {
+            Ok(())
         }
-
-        Ok(())
     }
 }
 

src/librustc_borrowck/borrowck/mir/mod.rs

@@ -17,6 +17,7 @@ use rustc_front::hir;
 use rustc_front::intravisit::{FnKind};
 
 use rustc::mir::repr::{BasicBlock, BasicBlockData, Mir, Statement, Terminator};
+use rustc::session::Session;
 
 mod abs_domain;
 mod dataflow;
@@ -30,6 +31,12 @@ use self::gather_moves::{MoveData};
 
 use std::fmt::Debug;
 
+pub struct BorrowckMirData<'tcx> {
+    move_data: MoveData<'tcx>,
+    flow_inits: DataflowState<MaybeInitializedLvals<'tcx>>,
+    flow_uninits: DataflowState<MaybeUninitializedLvals<'tcx>>,
+}
+
 pub fn borrowck_mir<'b, 'a: 'b, 'tcx: 'a>(
     bcx: &'b mut BorrowckCtxt<'a, 'tcx>,
     fk: FnKind,
@@ -38,7 +45,7 @@ pub fn borrowck_mir<'b, 'a: 'b, 'tcx: 'a>(
     body: &hir::Block,
     _sp: Span,
     id: ast::NodeId,
-    attributes: &[ast::Attribute]) {
+    attributes: &[ast::Attribute]) -> BorrowckMirData<'tcx> {
     match fk {
         FnKind::ItemFn(name, _, _, _, _, _, _) |
         FnKind::Method(name, _, _, _) => {
@@ -60,7 +67,6 @@ pub fn borrowck_mir<'b, 'a: 'b, 'tcx: 'a>(
         bcx: bcx,
         mir: mir,
         node_id: id,
-        attributes: attributes,
         move_data: move_data,
         flow_inits: flow_inits,
         flow_uninits: flow_uninits,
@@ -72,6 +78,12 @@ pub fn borrowck_mir<'b, 'a: 'b, 'tcx: 'a>(
 
     debug!("borrowck_mir done");
 
+    return BorrowckMirData {
+        move_data: mbcx.move_data,
+        flow_inits: mbcx.flow_inits,
+        flow_uninits: mbcx.flow_uninits,
+    };
+
     fn do_dataflow<'a, 'tcx, BD>(bcx: &mut BorrowckCtxt<'a, 'tcx>,
                                  mir: &'a Mir<'tcx>,
                                  node_id: NodeId,
@@ -80,11 +92,40 @@ pub fn borrowck_mir<'b, 'a: 'b, 'tcx: 'a>(
                                  bd: BD) -> (MoveData<'tcx>, DataflowState<BD>)
         where BD: BitDenotation<Ctxt=MoveData<'tcx>>, BD::Bit: Debug
     {
+        use syntax::attr::AttrMetaMethods;
+
+        let attr_meta_name_found = |sess: &Session, attributes: &[ast::Attribute], name| -> Option<String> {
+            for attr in attributes {
+                if attr.check_name("rustc_mir") {
+                    let items = attr.meta_item_list();
+                    for item in items.iter().flat_map(|l| l.iter()) {
+                        if item.check_name(name) {
+                            if let Some(s) = item.value_str() {
+                                return Some(s.to_string())
+                            } else {
+                                sess.span_err(
+                                    item.span,
+                                    &format!("{} attribute requires a path", item.name()));
+                                return None;
+                            }
+                        }
+                    }
+                }
+            }
+            return None;
+        };
+
+        let print_preflow_to =
+            attr_meta_name_found(bcx.tcx.sess, attributes, "borrowck_graphviz_preflow");
+        let print_postflow_to =
+            attr_meta_name_found(bcx.tcx.sess, attributes, "borrowck_graphviz_postflow");
+
         let mut mbcx = MirBorrowckCtxtPreDataflow {
             bcx: bcx,
             mir: mir,
             node_id: node_id,
-            attributes: attributes,
+            print_preflow_to: print_preflow_to,
+            print_postflow_to: print_postflow_to,
             flow_state: DataflowStateBuilder::new(mir, move_data, bd),
         };
 
@@ -99,15 +140,15 @@ pub struct MirBorrowckCtxtPreDataflow<'b, 'a: 'b, 'tcx: 'a, BD>
     bcx: &'b mut BorrowckCtxt<'a, 'tcx>,
     mir: &'b Mir<'tcx>,
     node_id: ast::NodeId,
-    attributes: &'b [ast::Attribute],
+    print_preflow_to: Option<String>,
+    print_postflow_to: Option<String>,
     flow_state: DataflowStateBuilder<'a, 'tcx, BD>,
 }
 
 pub struct MirBorrowckCtxt<'b, 'a: 'b, 'tcx: 'a> {
     bcx: &'b mut BorrowckCtxt<'a, 'tcx>,
     mir: &'b Mir<'tcx>,
     node_id: ast::NodeId,
-    attributes: &'b [ast::Attribute],
     move_data: MoveData<'tcx>,
     flow_inits: DataflowState<MaybeInitializedLvals<'tcx>>,
     flow_uninits: DataflowState<MaybeUninitializedLvals<'tcx>>,

src/librustc_borrowck/borrowck/mod.rs

@@ -170,7 +170,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt,
     if attributes.iter().any(|item| item.check_name("rustc_mir_borrowck")) {
         let mir = this.mir_map.unwrap().map.get(&id).unwrap();
         this.with_temp_region_map(id, |this| {
-            mir::borrowck_mir(this, fk, decl, mir, body, sp, id, attributes)
+            mir::borrowck_mir(this, fk, decl, mir, body, sp, id, attributes);
         });
     }