use crate::util;
use log::{info, log_enabled, warn};
-use rustc::arena::Arena;
-use rustc::dep_graph::DepGraph;
-use rustc::hir::map;
-use rustc::lint;
-use rustc::middle;
-use rustc::middle::cstore::{CrateStore, MetadataLoader, MetadataLoaderDyn};
-use rustc::session::config::{self, CrateType, Input, OutputFilenames, OutputType};
-use rustc::session::config::{PpMode, PpSourceMode};
-use rustc::session::search_paths::PathKind;
-use rustc::session::Session;
-use rustc::ty::steal::Steal;
-use rustc::ty::{self, GlobalCtxt, ResolverOutputs, TyCtxt};
-use rustc::util::common::ErrorReported;
use rustc_ast::mut_visit::MutVisitor;
use rustc_ast::{self, ast, visit};
use rustc_codegen_ssa::back::link::emit_metadata;
-use rustc_codegen_utils::codegen_backend::CodegenBackend;
-use rustc_codegen_utils::link::filename_for_metadata;
+use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_data_structures::sync::{par_iter, Lrc, Once, ParallelIterator, WorkerLocal};
use rustc_data_structures::{box_region_allow_access, declare_box_region_type, parallel};
-use rustc_errors::PResult;
+use rustc_errors::{ErrorReported, PResult};
use rustc_expand::base::ExtCtxt;
use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
+use rustc_hir::definitions::Definitions;
use rustc_hir::Crate;
-use rustc_infer::traits;
use rustc_lint::LintStore;
+use rustc_middle::arena::Arena;
+use rustc_middle::dep_graph::DepGraph;
+use rustc_middle::middle;
+use rustc_middle::middle::cstore::{CrateStore, MetadataLoader, MetadataLoaderDyn};
+use rustc_middle::ty::steal::Steal;
+use rustc_middle::ty::{self, GlobalCtxt, ResolverOutputs, TyCtxt};
use rustc_mir as mir;
use rustc_mir_build as mir_build;
use rustc_parse::{parse_crate_from_file, parse_crate_from_source_str};
use rustc_passes::{self, hir_stats, layout_test};
use rustc_plugin_impl as plugin;
use rustc_resolve::{Resolver, ResolverArenas};
+use rustc_session::config::{
+ self, CrateType, Input, OutputFilenames, OutputType, PpMode, PpSourceMode,
+};
+use rustc_session::lint;
+use rustc_session::output::{filename_for_input, filename_for_metadata};
+use rustc_session::search_paths::PathKind;
+use rustc_session::Session;
use rustc_span::symbol::Symbol;
-use rustc_span::FileName;
+use rustc_span::{FileName, RealFileName};
+use rustc_trait_selection::traits;
use rustc_typeck as typeck;
use rustc_serialize::json;
Ok((krate, Lrc::new(lint_store)))
}
-fn configure_and_expand_inner<'a>(
- sess: &'a Session,
- lint_store: &'a LintStore,
- mut krate: ast::Crate,
- crate_name: &str,
- resolver_arenas: &'a ResolverArenas<'a>,
- metadata_loader: &'a MetadataLoaderDyn,
-) -> Result<(ast::Crate, Resolver<'a>)> {
+fn pre_expansion_lint(sess: &Session, lint_store: &LintStore, krate: &ast::Crate) {
sess.time("pre_AST_expansion_lint_checks", || {
rustc_lint::check_ast_crate(
sess,
rustc_lint::BuiltinCombinedPreExpansionLintPass::new(),
);
});
+}
+
+fn configure_and_expand_inner<'a>(
+ sess: &'a Session,
+ lint_store: &'a LintStore,
+ mut krate: ast::Crate,
+ crate_name: &str,
+ resolver_arenas: &'a ResolverArenas<'a>,
+ metadata_loader: &'a MetadataLoaderDyn,
+) -> Result<(ast::Crate, Resolver<'a>)> {
+ pre_expansion_lint(sess, lint_store, &krate);
let mut resolver = Resolver::new(sess, &krate, crate_name, metadata_loader, &resolver_arenas);
rustc_builtin_macros::register_builtin_macros(&mut resolver, sess.edition());
..rustc_expand::expand::ExpansionConfig::default(crate_name.to_string())
};
- let mut ecx = ExtCtxt::new(&sess.parse_sess, cfg, &mut resolver);
+ let extern_mod_loaded = |k: &ast::Crate| pre_expansion_lint(sess, lint_store, k);
+ let mut ecx = ExtCtxt::new(&sess.parse_sess, cfg, &mut resolver, Some(&extern_mod_loaded));
// Expand macros now!
let krate = sess.time("expand_crate", || ecx.monotonic_expander().expand_crate(krate));
ecx.parse_sess.missing_fragment_specifiers.borrow().iter().cloned().collect();
missing_fragment_specifiers.sort();
+ let recursion_limit_hit = ecx.reduced_recursion_limit.is_some();
+
for span in missing_fragment_specifiers {
let lint = lint::builtin::MISSING_FRAGMENT_SPECIFIER;
let msg = "missing fragment specifier";
if cfg!(windows) {
env::set_var("PATH", &old_path);
}
- krate
- });
+
+ if recursion_limit_hit {
+ // If we hit a recursion limit, exit early to avoid later passes getting overwhelmed
+ // with a large AST
+ Err(ErrorReported)
+ } else {
+ Ok(krate)
+ }
+ })?;
sess.time("maybe_building_test_harness", || {
rustc_builtin_macros::test_harness::inject(
resolver: &'res mut Resolver<'_>,
dep_graph: &'res DepGraph,
krate: &'res ast::Crate,
- arena: &'tcx Arena<'tcx>,
+ arena: &'tcx rustc_ast_lowering::Arena<'tcx>,
) -> Crate<'tcx> {
+ // We're constructing the HIR here; we don't care what we will
+ // read, since we haven't even constructed the *input* to
+ // incr. comp. yet.
+ dep_graph.assert_ignored();
+
// Lower AST to HIR.
let hir_crate = rustc_ast_lowering::lower_crate(
sess,
- &dep_graph,
&krate,
resolver,
rustc_parse::nt_to_tokenstream,
// by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
OutputType::Exe if !exact_name => {
for crate_type in sess.crate_types.borrow().iter() {
- let p = ::rustc_codegen_utils::link::filename_for_input(
- sess,
- *crate_type,
- crate_name,
- outputs,
- );
+ let p = filename_for_input(sess, *crate_type, crate_name, outputs);
out_filenames.push(p);
}
}
for cnum in resolver.cstore().crates_untracked() {
let source = resolver.cstore().crate_source_untracked(cnum);
if let Some((path, _)) = source.dylib {
- files.push(escape_dep_filename(&FileName::Real(path)));
+ let file_name = FileName::Real(RealFileName::Named(path));
+ files.push(escape_dep_filename(&file_name));
}
if let Some((path, _)) = source.rlib {
- files.push(escape_dep_filename(&FileName::Real(path)));
+ let file_name = FileName::Real(RealFileName::Named(path));
+ files.push(escape_dep_filename(&file_name));
}
if let Some((path, _)) = source.rmeta {
- files.push(escape_dep_filename(&FileName::Real(path)));
+ let file_name = FileName::Real(RealFileName::Named(path));
+ files.push(escape_dep_filename(&file_name));
}
}
});
providers.analysis = analysis;
proc_macro_decls::provide(providers);
plugin::build::provide(providers);
- rustc::hir::provide(providers);
+ rustc_middle::hir::provide(providers);
mir::provide(providers);
mir_build::provide(providers);
rustc_privacy::provide(providers);
rustc_ty::provide(providers);
rustc_metadata::provide(providers);
rustc_lint::provide(providers);
- rustc_codegen_utils::provide(providers);
+ rustc_symbol_mangling::provide(providers);
rustc_codegen_ssa::provide(providers);
}
where
F: FnOnce(TyCtxt<'tcx>) -> R,
{
- ty::tls::enter_global(self.0, |tcx| f(tcx))
+ ty::tls::enter_global(self.0, f)
}
pub fn print_stats(&mut self) {
- self.enter(|tcx| ty::query::print_stats(tcx))
+ self.enter(ty::query::print_stats)
}
}
arena: &'tcx WorkerLocal<Arena<'tcx>>,
) -> QueryContext<'tcx> {
let sess = &compiler.session();
- let defs = mem::take(&mut resolver_outputs.definitions);
-
- // Construct the HIR map.
- let hir_map = map::map_crate(sess, &*resolver_outputs.cstore, krate, dep_graph, defs);
+ let defs: &'tcx Definitions = arena.alloc(mem::take(&mut resolver_outputs.definitions));
let query_result_on_disk_cache = rustc_incremental::load_query_result_cache(sess);
extern_providers,
arena,
resolver_outputs,
- hir_map,
+ krate,
+ defs,
+ dep_graph,
query_result_on_disk_cache,
&crate_name,
&outputs,
fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
assert_eq!(cnum, LOCAL_CRATE);
+ rustc_passes::hir_id_validator::check_crate(tcx);
+
let sess = tcx.sess;
let mut entry_point = None;
{
sess.time("match_checking", || {
tcx.par_body_owners(|def_id| {
- tcx.ensure().check_match(def_id);
+ tcx.ensure().check_match(def_id.to_def_id());
});
});
},
});
sess.time("MIR_borrow_checking", || {
- tcx.par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
+ tcx.par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id.to_def_id()));
});
sess.time("dumping_chalk_like_clauses", || {
sess.time("MIR_effect_checking", || {
for def_id in tcx.body_owners() {
- mir::transform::check_unsafety::check_unsafety(tcx, def_id)
+ mir::transform::check_unsafety::check_unsafety(tcx, def_id.to_def_id())
}
});
projects / rustc.git / blobdiff