bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #33450 - SiegeLord:dep_info_no_analysis, r=nrc

Browse source 
Make --emit dep-info work correctly with -Z no-analysis again.

Previously, it would attempt to resolve some external crates that weren't necessary for dep-info output.

Fixes #33231.
This commit is contained in:
bors 2016-05-12 19:52:51 -07:00
commit 01ed700640
6 changed files with 97 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

71
src/librustc_driver/driver.rs
View file

@ -138,6 +138,19 @@ pub fn compile_input(sess: &Session,
&id), &id),
Ok(())); Ok(()));
write_out_deps(sess, &outputs, &id);
controller_entry_point!(after_write_deps,
sess,
CompileState::state_after_write_deps(input,
sess,
outdir,
output,
&cstore,
&expanded_crate,
&id),
Ok(()));
let expanded_crate = assign_node_ids(sess, expanded_crate); let expanded_crate = assign_node_ids(sess, expanded_crate);
let dep_graph = DepGraph::new(sess.opts.build_dep_graph()); let dep_graph = DepGraph::new(sess.opts.build_dep_graph());
@ -173,25 +186,22 @@ pub fn compile_input(sess: &Session,
"indexing hir", "indexing hir",
move || hir_map::map_crate(hir_forest, defs)); move || hir_map::map_crate(hir_forest, defs));
write_out_deps(sess, &outputs, &id);
{ {
let _ignore = hir_map.dep_graph.in_ignore(); let _ignore = hir_map.dep_graph.in_ignore();
controller_entry_point!(after_write_deps, controller_entry_point!(after_hir_lowering,
sess, sess,
CompileState::state_after_write_deps(input, CompileState::state_after_hir_lowering(input,
sess, sess,
outdir, outdir,
output, output,
&arenas, &arenas,
&cstore, &cstore,
&hir_map, &hir_map,
&analysis, &analysis,
&resolutions, &resolutions,
&expanded_crate, &expanded_crate,
&hir_map.krate(), &hir_map.krate(),
&id), &id),
Ok(())); Ok(()));
} }
@ -311,6 +321,7 @@ pub struct CompileController<'a> {
pub after_parse: PhaseController<'a>, pub after_parse: PhaseController<'a>,
pub after_expand: PhaseController<'a>, pub after_expand: PhaseController<'a>,
pub after_write_deps: PhaseController<'a>, pub after_write_deps: PhaseController<'a>,
pub after_hir_lowering: PhaseController<'a>,
pub after_analysis: PhaseController<'a>, pub after_analysis: PhaseController<'a>,
pub after_llvm: PhaseController<'a>, pub after_llvm: PhaseController<'a>,
@ -323,6 +334,7 @@ impl<'a> CompileController<'a> {
after_parse: PhaseController::basic(), after_parse: PhaseController::basic(),
after_expand: PhaseController::basic(), after_expand: PhaseController::basic(),
after_write_deps: PhaseController::basic(), after_write_deps: PhaseController::basic(),
after_hir_lowering: PhaseController::basic(),
after_analysis: PhaseController::basic(), after_analysis: PhaseController::basic(),
after_llvm: PhaseController::basic(), after_llvm: PhaseController::basic(),
make_glob_map: resolve::MakeGlobMap::No, make_glob_map: resolve::MakeGlobMap::No,
@ -433,15 +445,32 @@ impl<'a, 'b, 'ast, 'tcx> CompileState<'a, 'b, 'ast, 'tcx> {
session: &'ast Session, session: &'ast Session,
out_dir: &'a Option<PathBuf>, out_dir: &'a Option<PathBuf>,
out_file: &'a Option<PathBuf>, out_file: &'a Option<PathBuf>,
arenas: &'ast ty::CtxtArenas<'ast>,
cstore: &'a CStore, cstore: &'a CStore,
hir_map: &'a hir_map::Map<'ast>,
analysis: &'a ty::CrateAnalysis,
resolutions: &'a Resolutions,
krate: &'a ast::Crate, krate: &'a ast::Crate,
hir_crate: &'a hir::Crate,
crate_name: &'a str) crate_name: &'a str)
-> CompileState<'a, 'b, 'ast, 'tcx> { -> CompileState<'a, 'b, 'ast, 'tcx> {
CompileState {
crate_name: Some(crate_name),
cstore: Some(cstore),
expanded_crate: Some(krate),
out_file: out_file.as_ref().map(|s| &**s),
..CompileState::empty(input, session, out_dir)
}
}
fn state_after_hir_lowering(input: &'a Input,
session: &'ast Session,
out_dir: &'a Option<PathBuf>,
out_file: &'a Option<PathBuf>,
arenas: &'ast ty::CtxtArenas<'ast>,
cstore: &'a CStore,
hir_map: &'a hir_map::Map<'ast>,
analysis: &'a ty::CrateAnalysis,
resolutions: &'a Resolutions,
krate: &'a ast::Crate,
hir_crate: &'a hir::Crate,
crate_name: &'a str)
-> CompileState<'a, 'b, 'ast, 'tcx> {
CompileState { CompileState {
crate_name: Some(crate_name), crate_name: Some(crate_name),
arenas: Some(arenas), arenas: Some(arenas),

26
src/librustc_driver/lib.rs
View file

@ -461,23 +461,23 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
if let Some((ppm, opt_uii)) = parse_pretty(sess, matches) { if let Some((ppm, opt_uii)) = parse_pretty(sess, matches) {
if ppm.needs_ast_map(&opt_uii) { if ppm.needs_ast_map(&opt_uii) {
control.after_write_deps.stop = Compilation::Stop; control.after_hir_lowering.stop = Compilation::Stop;
control.after_parse.callback = box move |state| { control.after_parse.callback = box move |state| {
state.krate = Some(pretty::fold_crate(state.krate.take().unwrap(), ppm)); state.krate = Some(pretty::fold_crate(state.krate.take().unwrap(), ppm));
}; };
control.after_write_deps.callback = box move |state| { control.after_hir_lowering.callback = box move |state| {
pretty::print_after_write_deps(state.session, pretty::print_after_hir_lowering(state.session,
state.ast_map.unwrap(), state.ast_map.unwrap(),
state.analysis.unwrap(), state.analysis.unwrap(),
state.resolutions.unwrap(), state.resolutions.unwrap(),
state.input, state.input,
&state.expanded_crate.take().unwrap(), &state.expanded_crate.take().unwrap(),
state.crate_name.unwrap(), state.crate_name.unwrap(),
ppm, ppm,
state.arenas.unwrap(), state.arenas.unwrap(),
opt_uii.clone(), opt_uii.clone(),
state.out_file); state.out_file);
}; };
} else { } else {
control.after_parse.stop = Compilation::Stop; control.after_parse.stop = Compilation::Stop;

22
src/librustc_driver/pretty.rs
View file

@ -812,17 +812,17 @@ pub fn print_after_parsing(sess: &Session,
write_output(out, ofile); write_output(out, ofile);
} }
pub fn print_after_write_deps<'tcx, 'a: 'tcx>(sess: &'a Session, pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session,
ast_map: &hir_map::Map<'tcx>, ast_map: &hir_map::Map<'tcx>,
analysis: &ty::CrateAnalysis, analysis: &ty::CrateAnalysis,
resolutions: &Resolutions, resolutions: &Resolutions,
input: &Input, input: &Input,
krate: &ast::Crate, krate: &ast::Crate,
crate_name: &str, crate_name: &str,
ppm: PpMode, ppm: PpMode,
arenas: &'tcx ty::CtxtArenas<'tcx>, arenas: &'tcx ty::CtxtArenas<'tcx>,
opt_uii: Option<UserIdentifiedItem>, opt_uii: Option<UserIdentifiedItem>,
ofile: Option<&Path>) { ofile: Option<&Path>) {
let dep_graph = DepGraph::new(false); let dep_graph = DepGraph::new(false);
let _ignore = dep_graph.in_ignore(); let _ignore = dep_graph.in_ignore();

6
src/test/run-make/dep-info-no-analysis/Makefile Normal file
View file

@ -0,0 +1,6 @@
-include ../tools.mk
all:
$(RUSTC) -o $(TMPDIR)/input.dd -Z no-analysis --emit dep-info input.rs
sed -i'.bak' 's/^.*input.dd/input.dd/g' $(TMPDIR)/input.dd
diff -u $(TMPDIR)/input.dd input.dd

3
src/test/run-make/dep-info-no-analysis/input.dd Normal file
View file

@ -0,0 +1,3 @@
input.dd: input.rs
input.rs:

14
src/test/run-make/dep-info-no-analysis/input.rs Normal file
View file

@ -0,0 +1,14 @@
// Copyright 2014 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.
// Tests that dep info can be emitted without resolving external crates.
extern crate not_there;
fn main() {}