mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move run_renderer into the main global_ctxt closure

Browse Source
This commit is contained in:
Joshua Nelson 2020-12-11 21:57:48 -05:00
parent 34e8b0aae1
commit 79ab333cf0
2 changed files with 81 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/librustdoc/core.rs
View File

@ -274,7 +274,7 @@ where
}
/// Parse, resolve, and typecheck the given crate.
fn create_config(
crate fn create_config(
RustdocOptions {
input,
crate_name,
@ -406,50 +406,7 @@ fn create_config(
}
}
crate fn run_core(
options: RustdocOptions,
) -> (clean::Crate, RenderInfo, RenderOptions, Lrc<Session>) {
let default_passes = options.default_passes;
let output_format = options.output_format;
// TODO: fix this clone (especially render_options)
let externs = options.externs.clone();
let manual_passes = options.manual_passes.clone();
let render_options = options.render_options.clone();
let config = create_config(options);
interface::create_compiler_and_run(config, |compiler| {
compiler.enter(|queries| {
let sess = compiler.session();
// We need to hold on to the complete resolver, so we cause everything to be
// cloned for the analysis passes to use. Suboptimal, but necessary in the
// current architecture.
let resolver = create_resolver(externs, queries, &sess);
if sess.has_errors() {
sess.fatal("Compilation failed, aborting rustdoc");
}
let mut global_ctxt = abort_on_err(queries.global_ctxt(), sess).take();
let (krate, render_info, opts) = sess.time("run_global_ctxt", || {
global_ctxt.enter(|tcx| {
run_global_ctxt(
tcx,
resolver,
default_passes,
manual_passes,
render_options,
output_format,
)
})
});
(krate, render_info, opts, Lrc::clone(sess))
})
})
}
fn create_resolver<'a>(
crate fn create_resolver<'a>(
externs: config::Externs,
queries: &Queries<'a>,
sess: &Session,
@ -489,7 +446,7 @@ fn create_resolver<'a>(
resolver.clone()
}
fn run_global_ctxt(
crate fn run_global_ctxt(
tcx: TyCtxt<'_>,
resolver: Rc<RefCell<interface::BoxedResolver>>,
mut default_passes: passes::DefaultPassOption,

103
src/librustdoc/lib.rs
View File

@ -63,7 +63,9 @@ use std::env;
use std::process;
use rustc_data_structures::sync::Lrc;
use rustc_driver::abort_on_err;
use rustc_errors::ErrorReported;
use rustc_interface::interface;
use rustc_session::config::{make_crate_type_option, ErrorOutputType, RustcOptGroup};
use rustc_session::getopts;
use rustc_session::Session;
@ -520,34 +522,85 @@ fn main_options(options: config::Options) -> MainResult {
// then generated from the cleaned AST of the crate. This runs all the
// plug/cleaning passes.
let crate_version = options.crate_version.clone();
let default_passes = options.default_passes;
let output_format = options.output_format;
let (mut krate, renderinfo, renderopts, sess) = core::run_core(options);
// TODO: fix this clone (especially render_options)
let externs = options.externs.clone();
let manual_passes = options.manual_passes.clone();
let render_options = options.render_options.clone();
let config = core::create_config(options);
info!("finished with rustc");
interface::create_compiler_and_run(config, |compiler| {
compiler.enter(|queries| {
let sess = compiler.session();
krate.version = crate_version;
// We need to hold on to the complete resolver, so we cause everything to be
// cloned for the analysis passes to use. Suboptimal, but necessary in the
// current architecture.
let resolver = core::create_resolver(externs, queries, &sess);
if show_coverage {
// if we ran coverage, bail early, we don't need to also generate docs at this point
// (also we didn't load in any of the useful passes)
return Ok(());
} else if run_check {
// Since we're in "check" mode, no need to generate anything beyond this point.
return Ok(());
}
if sess.has_errors() {
sess.fatal("Compilation failed, aborting rustdoc");
}
info!("going to format");
let (error_format, edition, debugging_options) = diag_opts;
let diag = core::new_handler(error_format, None, &debugging_options);
let sess_time = sess.clone();
match output_format {
None | Some(config::OutputFormat::Html) => sess_time.time("render_html", || {
run_renderer::<html::render::Context>(
krate, renderopts, renderinfo, &diag, edition, sess,
)
}),
Some(config::OutputFormat::Json) => sess_time.time("render_json", || {
run_renderer::<json::JsonRenderer>(krate, renderopts, renderinfo, &diag, edition, sess)
}),
}
let mut global_ctxt = abort_on_err(queries.global_ctxt(), sess).take();
global_ctxt.enter(|tcx| {
let (mut krate, render_info, render_opts) = sess.time("run_global_ctxt", || {
core::run_global_ctxt(
tcx,
resolver,
default_passes,
manual_passes,
render_options,
output_format,
)
});
info!("finished with rustc");
if let Some(name) = crate_name {
krate.name = name
}
krate.version = crate_version;
if show_coverage {
// if we ran coverage, bail early, we don't need to also generate docs at this point
// (also we didn't load in any of the useful passes)
return Ok(());
} else if run_check {
// Since we're in "check" mode, no need to generate anything beyond this point.
return Ok(());
}
info!("going to format");
let (error_format, edition, debugging_options) = diag_opts;
let diag = core::new_handler(error_format, None, &debugging_options);
let sess_format = sess.clone();
match output_format {
None | Some(config::OutputFormat::Html) => sess.time("render_html", || {
run_renderer::<html::render::Context>(
krate,
render_opts,
render_info,
&diag,
edition,
sess_format,
)
}),
Some(config::OutputFormat::Json) => sess.time("render_json", || {
run_renderer::<json::JsonRenderer>(
krate,
render_opts,
render_info,
&diag,
edition,
sess_format,
)
}),
}
})
})
})
}