Factor out MIR printer into a pass

Author: nagisa

src/librustc/dep_graph/mod.rs

@@ -70,6 +70,7 @@ pub enum DepNode {
     IntrinsicCheck(DefId),
     MatchCheck(DefId),
     MirMapConstruction(DefId),
+    MirPrintPass,
     BorrowCheck(DefId),
     RvalueCheck(DefId),
     Reachability,

src/librustc_driver/driver.rs

@@ -856,6 +856,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
             // Push all the built-in passes.
             passes.push_pass(box transform::simplify_cfg::SimplifyCfg);
             passes.push_pass(box transform::erase_regions::EraseRegions);
+            passes.push_pass(box transform::print::MirPrint);
             passes.push_pass(box transform::simplify_cfg::CompactMir);
             // And run everything.
             passes.run_passes(tcx, &mut mir_map);

src/librustc_mir/mir_map.rs

@@ -8,24 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! An experimental pass that scources for `#[rustc_mir]` attributes,
-//! builds the resulting MIR, and dumps it out into a file for inspection.
-//!
-//! The attribute formats that are currently accepted are:
-//!
-//! - `#[rustc_mir(graphviz="file.gv")]`
-//! - `#[rustc_mir(pretty="file.mir")]`
+//! An pass that builds the MIR for each item and stores it into the map.
 
 extern crate syntax;
 extern crate rustc_front;
 
 use build;
-use graphviz;
-use pretty;
 use rustc::dep_graph::DepNode;
 use rustc::mir::repr::Mir;
 use hair::cx::Cx;
-use std::fs::File;
 
 use rustc::mir::mir_map::MirMap;
 use rustc::middle::infer;
@@ -133,55 +124,14 @@ impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
                 body: &'tcx hir::Block,
                 span: Span,
                 id: ast::NodeId) {
-        let (prefix, implicit_arg_tys) = match fk {
-            intravisit::FnKind::Closure =>
-                (format!("{}-", id), vec![closure_self_ty(&self.tcx, id, body.id)]),
-            _ =>
-                (format!(""), vec![]),
+        let implicit_arg_tys = match fk {
+            intravisit::FnKind::Closure => vec![closure_self_ty(&self.tcx, id, body.id)],
+            _ => vec![],
         };
-
         let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
-
         let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env));
-
         match build_mir(Cx::new(&infcx), implicit_arg_tys, id, span, decl, body) {
-            Ok(mir) => {
-                let meta_item_list = self.attr
-                                         .iter()
-                                         .flat_map(|a| a.meta_item_list())
-                                         .flat_map(|l| l.iter());
-                for item in meta_item_list {
-                    if item.check_name("graphviz") || item.check_name("pretty") {
-                        match item.value_str() {
-                            Some(s) => {
-                                let filename = format!("{}{}", prefix, s);
-                                let result = File::create(&filename).and_then(|ref mut output| {
-                                    if item.check_name("graphviz") {
-                                        graphviz::write_mir_graphviz(&mir, output)
-                                    } else {
-                                        pretty::write_mir_pretty(&mir, output)
-                                    }
-                                });
-
-                                if let Err(e) = result {
-                                    self.tcx.sess.span_fatal(
-                                        item.span,
-                                        &format!("Error writing MIR {} results to `{}`: {}",
-                                                 item.name(), filename, e));
-                                }
-                            }
-                            None => {
-                                self.tcx.sess.span_err(
-                                    item.span,
-                                    &format!("{} attribute requires a path", item.name()));
-                            }
-                        }
-                    }
-                }
-
-                let previous = self.map.map.insert(id, mir);
-                assert!(previous.is_none());
-            }
+            Ok(mir) => assert!(self.map.map.insert(id, mir).is_none()),
             Err(ErrorReported) => {}
         }
 

src/librustc_mir/transform/mod.rs

@@ -10,4 +10,5 @@
 
 pub mod simplify_cfg;
 pub mod erase_regions;
+pub mod print;
 mod util;

src/librustc_mir/transform/print.rs

@@ -0,0 +1,73 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! This pass handles the `#[rustc_mir(*)]` attributes and prints the contents.
+//!
+//! The attribute formats that are currently accepted are:
+//!
+//! - `#[rustc_mir(graphviz="file.gv")]`
+//! - `#[rustc_mir(pretty="file.mir")]`
+use graphviz;
+use pretty;
+
+use syntax::attr::AttrMetaMethods;
+use rustc::middle::ty;
+use rustc::dep_graph::DepNode;
+use rustc::mir::mir_map::MirMap;
+use rustc::mir::transform::{MirMapPass, Pass};
+
+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>) {
+        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) {
+                if !attr.check_name("rustc_mir") {
+                    continue
+                }
+                for arg in attr.meta_item_list().iter().flat_map(|e| *e) {
+                    if arg.check_name("graphviz") || arg.check_name("pretty") {
+                        let filename = if let Some(p) = arg.value_str() {
+                            p
+                        } else {
+                            tcx.sess.span_err(arg.span,
+                                &format!("{} attribute requires a path", arg.name())
+                            );
+                            continue
+                        };
+                        let result = File::create(&*filename).and_then(|ref mut output| {
+                            if arg.check_name("graphviz") {
+                                graphviz::write_mir_graphviz(&mir, output)
+                            } else {
+                                pretty::write_mir_pretty(&mir, output)
+                            }
+                        });
+
+                        if let Err(e) = result {
+                            tcx.sess.span_err(arg.span,
+                                &format!("Error writing MIR {} output to `{}`: {}",
+                                         arg.name(), filename, e));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}