rustc_driver: move pretty-printing to the new driver controller API.

Author: eddyb

src/librustc_driver/driver.rs

@@ -69,10 +69,18 @@ pub fn compile_input(sess: Session,
         let (outputs, expanded_crate, id) = {
             let krate = phase_1_parse_input(&sess, cfg, input);
 
+            let krate = if control.every_body_loops {
+                use syntax::fold::Folder;
+                ::pretty::ReplaceBodyWithLoop::new().fold_crate(krate)
+            } else {
+                krate
+            };
+
             controller_entry_point!(after_parse,
                                     CompileState::state_after_parse(input,
                                                                     &sess,
                                                                     outdir,
+                                                                    output,
                                                                     &krate));
 
             let outputs = build_output_filenames(input,
@@ -99,6 +107,7 @@ pub fn compile_input(sess: Session,
                                 CompileState::state_after_expand(input,
                                                                  &sess,
                                                                  outdir,
+                                                                 output,
                                                                  &expanded_crate,
                                                                  &id[..]));
 
@@ -112,6 +121,7 @@ pub fn compile_input(sess: Session,
                                 CompileState::state_after_write_deps(input,
                                                                      &sess,
                                                                      outdir,
+                                                                     output,
                                                                      &ast_map,
                                                                      &ast_map.krate(),
                                                                      &id[..]));
@@ -126,6 +136,7 @@ pub fn compile_input(sess: Session,
                                 CompileState::state_after_analysis(input,
                                                                    &analysis.ty_cx.sess,
                                                                    outdir,
+                                                                   output,
                                                                    analysis.ty_cx.map.krate(),
                                                                    &analysis,
                                                                    &analysis.ty_cx));
@@ -152,6 +163,7 @@ pub fn compile_input(sess: Session,
                             CompileState::state_after_llvm(input,
                                                            &sess,
                                                            outdir,
+                                                           output,
                                                            &trans));
 
     phase_6_link_output(&sess, &trans, &outputs);
@@ -193,6 +205,7 @@ pub struct CompileController<'a> {
     pub after_llvm: PhaseController<'a>,
 
     pub make_glob_map: resolve::MakeGlobMap,
+    pub every_body_loops: bool,
 }
 
 impl<'a> CompileController<'a> {
@@ -204,6 +217,7 @@ impl<'a> CompileController<'a> {
             after_analysis: PhaseController::basic(),
             after_llvm: PhaseController::basic(),
             make_glob_map: resolve::MakeGlobMap::No,
+            every_body_loops: false,
         }
     }
 }
@@ -225,30 +239,33 @@ impl<'a> PhaseController<'a> {
 /// State that is passed to a callback. What state is available depends on when
 /// during compilation the callback is made. See the various constructor methods
 /// (`state_*`) in the impl to see which data is provided for any given entry point.
-pub struct CompileState<'a, 'ast: 'a, 'tcx: 'a> {
+pub struct CompileState<'a, 'tcx: 'a> {
     pub input: &'a Input,
     pub session: &'a Session,
     pub cfg: Option<&'a ast::CrateConfig>,
     pub krate: Option<&'a ast::Crate>,
     pub crate_name: Option<&'a str>,
     pub output_filenames: Option<&'a OutputFilenames>,
     pub out_dir: Option<&'a Path>,
+    pub output: Option<&'a Path>,
     pub expanded_crate: Option<&'a ast::Crate>,
-    pub ast_map: Option<&'a ast_map::Map<'ast>>,
+    pub ast_map: Option<&'a ast_map::Map<'tcx>>,
     pub analysis: Option<&'a ty::CrateAnalysis<'tcx>>,
     pub tcx: Option<&'a ty::ctxt<'tcx>>,
     pub trans: Option<&'a trans::CrateTranslation>,
 }
 
-impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
+impl<'a, 'tcx> CompileState<'a, 'tcx> {
     fn empty(input: &'a Input,
              session: &'a Session,
-             out_dir: &'a Option<Path>)
-             -> CompileState<'a, 'ast, 'tcx> {
+             out_dir: &'a Option<Path>,
+             output: &'a Option<Path>)
+             -> CompileState<'a, 'tcx> {
         CompileState {
             input: input,
             session: session,
             out_dir: out_dir.as_ref(),
+            output: output.as_ref(),
             cfg: None,
             krate: None,
             crate_name: None,
@@ -264,66 +281,71 @@ impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
     fn state_after_parse(input: &'a Input,
                          session: &'a Session,
                          out_dir: &'a Option<Path>,
+                         output: &'a Option<Path>,
                          krate: &'a ast::Crate)
-                         -> CompileState<'a, 'ast, 'tcx> {
+                         -> CompileState<'a, 'tcx> {
         CompileState {
             krate: Some(krate),
-            .. CompileState::empty(input, session, out_dir)
+            .. CompileState::empty(input, session, out_dir, output)
         }
     }
 
     fn state_after_expand(input: &'a Input,
                           session: &'a Session,
                           out_dir: &'a Option<Path>,
+                          output: &'a Option<Path>,
                           expanded_crate: &'a ast::Crate,
                           crate_name: &'a str)
-                          -> CompileState<'a, 'ast, 'tcx> {
+                          -> CompileState<'a, 'tcx> {
         CompileState {
             crate_name: Some(crate_name),
             expanded_crate: Some(expanded_crate),
-            .. CompileState::empty(input, session, out_dir)
+            .. CompileState::empty(input, session, out_dir, output)
         }
     }
 
     fn state_after_write_deps(input: &'a Input,
                               session: &'a Session,
                               out_dir: &'a Option<Path>,
-                              ast_map: &'a ast_map::Map<'ast>,
+                              output: &'a Option<Path>,
+                              ast_map: &'a ast_map::Map<'tcx>,
                               expanded_crate: &'a ast::Crate,
                               crate_name: &'a str)
-                              -> CompileState<'a, 'ast, 'tcx> {
+                              -> CompileState<'a, 'tcx> {
         CompileState {
             crate_name: Some(crate_name),
             ast_map: Some(ast_map),
             expanded_crate: Some(expanded_crate),
-            .. CompileState::empty(input, session, out_dir)
+            .. CompileState::empty(input, session, out_dir, output)
         }
     }
 
     fn state_after_analysis(input: &'a Input,
                             session: &'a Session,
                             out_dir: &'a Option<Path>,
+                            output: &'a Option<Path>,
                             expanded_crate: &'a ast::Crate,
                             analysis: &'a ty::CrateAnalysis<'tcx>,
                             tcx: &'a ty::ctxt<'tcx>)
-                            -> CompileState<'a, 'ast, 'tcx> {
+                            -> CompileState<'a, 'tcx> {
         CompileState {
             analysis: Some(analysis),
             tcx: Some(tcx),
             expanded_crate: Some(expanded_crate),
-            .. CompileState::empty(input, session, out_dir)
+            .. CompileState::empty(input, session, out_dir, output)
         }
     }
 
 
     fn state_after_llvm(input: &'a Input,
                         session: &'a Session,
                         out_dir: &'a Option<Path>,
+                        output: &'a Option<Path>,
                         trans: &'a trans::CrateTranslation)
-                        -> CompileState<'a, 'ast, 'tcx> {
+                        -> CompileState<'a, 'tcx> {
         CompileState {
             trans: Some(trans),
-            .. CompileState::empty(input, session, out_dir)
+            .. CompileState::empty(input, session, out_dir, output)
         }
     }
 }

src/librustc_driver/lib.rs

@@ -98,7 +98,7 @@ const BUG_REPORT_URL: &'static str =
 
 
 pub fn run(args: Vec<String>) -> int {
-    monitor(move || run_compiler(&args, &mut RustcDefaultCalls));
+    monitor(move || run_compiler(&args, &mut RustcDefaultCalls::new()));
     0
 }
 
@@ -142,13 +142,6 @@ pub fn run_compiler<'a>(args: &[String],
 
     do_or_return!(callbacks.late_callback(&matches, &sess, &input, &odir, &ofile));
 
-    // It is somewhat unfortunate that this is hardwired in - this is forced by
-    // the fact that pretty_print_input requires the session by value.
-    if let Some((ppm, opt_uii)) = callbacks.parse_pretty(&sess, &matches) {
-        pretty::pretty_print_input(sess, cfg, &input, ppm, opt_uii, ofile).unwrap();
-        return;
-    }
-
     let plugins = sess.opts.debugging_opts.extra_plugins.clone();
     let control = callbacks.build_controller(&sess);
     driver::compile_input(sess, cfg, &input, &odir, &ofile, Some(plugins), control);
@@ -235,33 +228,15 @@ pub trait CompilerCalls<'a> {
                 &diagnostics::registry::Registry)
                 -> Option<(Input, Option<Path>)>;
 
-    // Parse pretty printing information from the arguments. The implementer can
-    // choose to ignore this (the default will return None) which will skip pretty
-    // printing. If you do want to pretty print, it is recommended to use the
-    // implementation of this method from RustcDefaultCalls.
-    // FIXME, this is a terrible bit of API. Parsing of pretty printing stuff
-    // should be done as part of the framework and the implementor should customise
-    // handling of it. However, that is not possible atm because pretty printing
-    // essentially goes off and takes another path through the compiler which
-    // means the session is either moved or not depending on what parse_pretty
-    // returns (we could fix this by cloning, but it's another hack). The proper
-    // solution is to handle pretty printing as if it were a compiler extension,
-    // extending CompileController to make this work (see for example the treatment
-    // of save-analysis in RustcDefaultCalls::build_controller).
-    fn parse_pretty(&mut self,
-                    _sess: &Session,
-                    _matches: &getopts::Matches)
-                    -> Option<(PpMode, Option<UserIdentifiedItem>)> {
-        None
-    }
-
     // Create a CompilController struct for controlling the behaviour of compilation.
     fn build_controller(&mut self, &Session) -> CompileController<'a>;
 }
 
 // CompilerCalls instance for a regular rustc build.
-#[derive(Copy)]
-pub struct RustcDefaultCalls;
+pub struct RustcDefaultCalls {
+    save_analysis: bool,
+    pretty_print: Option<(PpMode, Option<UserIdentifiedItem>)>
+}
 
 impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
     fn early_callback(&mut self,
@@ -316,35 +291,25 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
         None
     }
 
-    fn parse_pretty(&mut self,
-                    sess: &Session,
-                    matches: &getopts::Matches)
-                    -> Option<(PpMode, Option<UserIdentifiedItem>)> {
-        let pretty = if sess.opts.debugging_opts.unstable_options {
-            matches.opt_default("pretty", "normal").map(|a| {
-                // stable pretty-print variants only
-                pretty::parse_pretty(sess, &a, false)
-            })
-        } else {
-            None
-        };
-        if pretty.is_none() && sess.unstable_options() {
-            matches.opt_str("xpretty").map(|a| {
-                // extended with unstable pretty-print variants
-                pretty::parse_pretty(sess, &a, true)
-            })
-        } else {
-            pretty
-        }
-    }
-
     fn late_callback(&mut self,
                      matches: &getopts::Matches,
                      sess: &Session,
                      input: &Input,
                      odir: &Option<Path>,
                      ofile: &Option<Path>)
                      -> Compilation {
+        self.save_analysis = sess.opts.debugging_opts.save_analysis;
+
+        if sess.unstable_options() {
+            self.pretty_print = matches.opt_default("pretty", "normal").map(|a| {
+                // stable pretty-print variants only
+                pretty::parse_pretty(sess, &a, false)
+            }).or_else(|| matches.opt_str("xpretty").map(|a| {
+                // extended with unstable pretty-print variants
+                pretty::parse_pretty(sess, &a, true)
+            }));
+        }
+
         RustcDefaultCalls::print_crate_info(sess, Some(input), odir, ofile).and_then(
             || RustcDefaultCalls::list_metadata(sess, matches, input))
     }
@@ -370,7 +335,17 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
             control.after_llvm.stop = Compilation::Stop;
         }
 
-        if sess.opts.debugging_opts.save_analysis {
+        if let Some((ppm, opt_uii)) = self.pretty_print.take() {
+            let phase = pretty::printing_phase(&mut control, ppm, opt_uii.as_ref());
+
+            phase.callback = box move |state| {
+                let output = state.output;
+                pretty::print_from_phase(state, ppm, opt_uii.as_ref(), output).unwrap();
+            };
+            phase.stop = Compilation::Stop;
+        }
+
+        if self.save_analysis {
             control.after_analysis.callback = box |state| {
                 time(state.session.time_passes(),
                      "save analysis", ||
@@ -387,6 +362,13 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
 }
 
 impl RustcDefaultCalls {
+    pub fn new() -> RustcDefaultCalls {
+        RustcDefaultCalls {
+            save_analysis: false,
+            pretty_print: None
+        }
+    }
+
     pub fn list_metadata(sess: &Session,
                          matches: &getopts::Matches,
                          input: &Input)