src/librustc_interface/passes.rs

   1 use crate::interface::{Compiler, Result};
   2 use crate::proc_macro_decls;
   3 use crate::util;
   4
   5 use log::{info, log_enabled, warn};
   6 use rustc::arena::Arena;
   7 use rustc::dep_graph::DepGraph;
   8 use rustc::hir::map;
   9 use rustc::lint;
  10 use rustc::middle;
  11 use rustc::middle::cstore::{CrateStore, MetadataLoader, MetadataLoaderDyn};
  12 use rustc::session::config::{self, CrateType, Input, OutputFilenames, OutputType};
  13 use rustc::session::config::{PpMode, PpSourceMode};
  14 use rustc::session::search_paths::PathKind;
  15 use rustc::session::Session;
  16 use rustc::traits;
  17 use rustc::ty::steal::Steal;
  18 use rustc::ty::{self, AllArenas, GlobalCtxt, ResolverOutputs, TyCtxt};
  19 use rustc::util::common::ErrorReported;
  20 use rustc_builtin_macros;
  21 use rustc_codegen_ssa::back::link::emit_metadata;
  22 use rustc_codegen_utils::codegen_backend::CodegenBackend;
  23 use rustc_codegen_utils::link::filename_for_metadata;
  24 use rustc_data_structures::sync::{par_iter, Lrc, Once, ParallelIterator, WorkerLocal};
  25 use rustc_data_structures::{box_region_allow_access, declare_box_region_type, parallel};
  26 use rustc_errors::PResult;
  27 use rustc_expand::base::ExtCtxt;
  28 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
  29 use rustc_incremental;
  30 use rustc_mir as mir;
  31 use rustc_parse::{parse_crate_from_file, parse_crate_from_source_str};
  32 use rustc_passes::{self, ast_validation, hir_stats, layout_test};
  33 use rustc_plugin_impl as plugin;
  34 use rustc_privacy;
  35 use rustc_resolve::{Resolver, ResolverArenas};
  36 use rustc_span::symbol::Symbol;
  37 use rustc_span::FileName;
  38 use rustc_traits;
  39 use rustc_typeck as typeck;
  40 use syntax::early_buffered_lints::BufferedEarlyLint;
  41 use syntax::mut_visit::MutVisitor;
  42 use syntax::util::node_count::NodeCounter;
  43 use syntax::{self, ast, visit};
  44
  45 use rustc_serialize::json;
  46 use tempfile::Builder as TempFileBuilder;
  47
  48 use std::any::Any;
  49 use std::cell::RefCell;
  50 use std::ffi::OsString;
  51 use std::io::{self, Write};
  52 use std::path::PathBuf;
  53 use std::rc::Rc;
  54 use std::{env, fs, iter, mem};
  55
  56 pub fn parse<'a>(sess: &'a Session, input: &Input) -> PResult<'a, ast::Crate> {
  57     let krate = sess.time("parse_crate", || match input {
  58         Input::File(file) => parse_crate_from_file(file, &sess.parse_sess),
  59         Input::Str { input, name } => {
  60             parse_crate_from_source_str(name.clone(), input.clone(), &sess.parse_sess)
  61         }
  62     })?;
  63
  64     if sess.opts.debugging_opts.ast_json_noexpand {
  65         println!("{}", json::as_json(&krate));
  66     }
  67
  68     if sess.opts.debugging_opts.input_stats {
  69         println!("Lines of code:             {}", sess.source_map().count_lines());
  70         println!("Pre-expansion node count:  {}", count_nodes(&krate));
  71     }
  72
  73     if let Some(ref s) = sess.opts.debugging_opts.show_span {
  74         syntax::show_span::run(sess.diagnostic(), s, &krate);
  75     }
  76
  77     if sess.opts.debugging_opts.hir_stats {
  78         hir_stats::print_ast_stats(&krate, "PRE EXPANSION AST STATS");
  79     }
  80
  81     Ok(krate)
  82 }
  83
  84 fn count_nodes(krate: &ast::Crate) -> usize {
  85     let mut counter = NodeCounter::new();
  86     visit::walk_crate(&mut counter, krate);
  87     counter.count
  88 }
  89
  90 declare_box_region_type!(
  91     pub BoxedResolver,
  92     for(),
  93     (&mut Resolver<'_>) -> (Result<ast::Crate>, ResolverOutputs)
  94 );
  95
  96 /// Runs the "early phases" of the compiler: initial `cfg` processing, loading compiler plugins,
  97 /// syntax expansion, secondary `cfg` expansion, synthesis of a test
  98 /// harness if one is to be provided, injection of a dependency on the
  99 /// standard library and prelude, and name resolution.
 100 ///
 101 /// Returns `None` if we're aborting after handling -W help.
 102 pub fn configure_and_expand(
 103     sess: Lrc<Session>,
 104     lint_store: Lrc<lint::LintStore>,
 105     metadata_loader: Box<MetadataLoaderDyn>,
 106     krate: ast::Crate,
 107     crate_name: &str,
 108 ) -> Result<(ast::Crate, BoxedResolver)> {
 109     // Currently, we ignore the name resolution data structures for the purposes of dependency
 110     // tracking. Instead we will run name resolution and include its output in the hash of each
 111     // item, much like we do for macro expansion. In other words, the hash reflects not just
 112     // its contents but the results of name resolution on those contents. Hopefully we'll push
 113     // this back at some point.
 114     let crate_name = crate_name.to_string();
 115     let (result, resolver) = BoxedResolver::new(static move || {
 116         let sess = &*sess;
 117         let resolver_arenas = Resolver::arenas();
 118         let res = configure_and_expand_inner(
 119             sess,
 120             &lint_store,
 121             krate,
 122             &crate_name,
 123             &resolver_arenas,
 124             &*metadata_loader,
 125         );
 126         let mut resolver = match res {
 127             Err(v) => {
 128                 yield BoxedResolver::initial_yield(Err(v));
 129                 panic!()
 130             }
 131             Ok((krate, resolver)) => {
 132                 yield BoxedResolver::initial_yield(Ok(krate));
 133                 resolver
 134             }
 135         };
 136         box_region_allow_access!(for(), (&mut Resolver<'_>), (&mut resolver));
 137         resolver.into_outputs()
 138     });
 139     result.map(|k| (k, resolver))
 140 }
 141
 142 impl BoxedResolver {
 143     pub fn to_resolver_outputs(resolver: Rc<RefCell<BoxedResolver>>) -> ResolverOutputs {
 144         match Rc::try_unwrap(resolver) {
 145             Ok(resolver) => resolver.into_inner().complete(),
 146             Err(resolver) => resolver.borrow_mut().access(|resolver| resolver.clone_outputs()),
 147         }
 148     }
 149 }
 150
 151 pub fn register_plugins<'a>(
 152     sess: &'a Session,
 153     metadata_loader: &'a dyn MetadataLoader,
 154     register_lints: impl Fn(&Session, &mut lint::LintStore),
 155     mut krate: ast::Crate,
 156     crate_name: &str,
 157 ) -> Result<(ast::Crate, Lrc<lint::LintStore>)> {
 158     krate = sess.time("attributes_injection", || {
 159         rustc_builtin_macros::cmdline_attrs::inject(
 160             krate,
 161             &sess.parse_sess,
 162             &sess.opts.debugging_opts.crate_attr,
 163         )
 164     });
 165
 166     let (krate, features) = rustc_expand::config::features(
 167         krate,
 168         &sess.parse_sess,
 169         sess.edition(),
 170         &sess.opts.debugging_opts.allow_features,
 171     );
 172     // these need to be set "early" so that expansion sees `quote` if enabled.
 173     sess.init_features(features);
 174
 175     let crate_types = util::collect_crate_types(sess, &krate.attrs);
 176     sess.crate_types.set(crate_types);
 177
 178     let disambiguator = util::compute_crate_disambiguator(sess);
 179     sess.crate_disambiguator.set(disambiguator);
 180     rustc_incremental::prepare_session_directory(sess, &crate_name, disambiguator);
 181
 182     if sess.opts.incremental.is_some() {
 183         sess.time("incr_comp_garbage_collect_session_directories", || {
 184             if let Err(e) = rustc_incremental::garbage_collect_session_directories(sess) {
 185                 warn!(
 186                     "Error while trying to garbage collect incremental \
 187                      compilation cache directory: {}",
 188                     e
 189                 );
 190             }
 191         });
 192     }
 193
 194     sess.time("recursion_limit", || {
 195         middle::recursion_limit::update_limits(sess, &krate);
 196     });
 197
 198     let mut lint_store = rustc_lint::new_lint_store(
 199         sess.opts.debugging_opts.no_interleave_lints,
 200         sess.unstable_options(),
 201     );
 202     register_lints(&sess, &mut lint_store);
 203
 204     let registrars =
 205         sess.time("plugin_loading", || plugin::load::load_plugins(sess, metadata_loader, &krate));
 206     sess.time("plugin_registration", || {
 207         let mut registry = plugin::Registry { lint_store: &mut lint_store };
 208         for registrar in registrars {
 209             registrar(&mut registry);
 210         }
 211     });
 212
 213     Ok((krate, Lrc::new(lint_store)))
 214 }
 215
 216 fn configure_and_expand_inner<'a>(
 217     sess: &'a Session,
 218     lint_store: &'a lint::LintStore,
 219     mut krate: ast::Crate,
 220     crate_name: &str,
 221     resolver_arenas: &'a ResolverArenas<'a>,
 222     metadata_loader: &'a MetadataLoaderDyn,
 223 ) -> Result<(ast::Crate, Resolver<'a>)> {
 224     sess.time("pre_AST_expansion_lint_checks", || {
 225         rustc_lint::check_ast_crate(
 226             sess,
 227             lint_store,
 228             &krate,
 229             true,
 230             None,
 231             rustc_lint::BuiltinCombinedPreExpansionLintPass::new(),
 232         );
 233     });
 234
 235     let mut resolver = Resolver::new(sess, &krate, crate_name, metadata_loader, &resolver_arenas);
 236     rustc_builtin_macros::register_builtin_macros(&mut resolver, sess.edition());
 237
 238     krate = sess.time("crate_injection", || {
 239         let alt_std_name = sess.opts.alt_std_name.as_ref().map(|s| Symbol::intern(s));
 240         let (krate, name) = rustc_builtin_macros::standard_library_imports::inject(
 241             krate,
 242             &mut resolver,
 243             &sess.parse_sess,
 244             alt_std_name,
 245         );
 246         if let Some(name) = name {
 247             sess.parse_sess.injected_crate_name.set(name);
 248         }
 249         krate
 250     });
 251
 252     util::check_attr_crate_type(&krate.attrs, &mut resolver.lint_buffer());
 253
 254     // Expand all macros
 255     krate = sess.time("macro_expand_crate", || {
 256         // Windows dlls do not have rpaths, so they don't know how to find their
 257         // dependencies. It's up to us to tell the system where to find all the
 258         // dependent dlls. Note that this uses cfg!(windows) as opposed to
 259         // targ_cfg because syntax extensions are always loaded for the host
 260         // compiler, not for the target.
 261         //
 262         // This is somewhat of an inherently racy operation, however, as
 263         // multiple threads calling this function could possibly continue
 264         // extending PATH far beyond what it should. To solve this for now we
 265         // just don't add any new elements to PATH which are already there
 266         // within PATH. This is basically a targeted fix at #17360 for rustdoc
 267         // which runs rustc in parallel but has been seen (#33844) to cause
 268         // problems with PATH becoming too long.
 269         let mut old_path = OsString::new();
 270         if cfg!(windows) {
 271             old_path = env::var_os("PATH").unwrap_or(old_path);
 272             let mut new_path = sess.host_filesearch(PathKind::All).search_path_dirs();
 273             for path in env::split_paths(&old_path) {
 274                 if !new_path.contains(&path) {
 275                     new_path.push(path);
 276                 }
 277             }
 278             env::set_var(
 279                 "PATH",
 280                 &env::join_paths(
 281                     new_path.iter().filter(|p| env::join_paths(iter::once(p)).is_ok()),
 282                 )
 283                 .unwrap(),
 284             );
 285         }
 286
 287         // Create the config for macro expansion
 288         let features = sess.features_untracked();
 289         let cfg = rustc_expand::expand::ExpansionConfig {
 290             features: Some(&features),
 291             recursion_limit: *sess.recursion_limit.get(),
 292             trace_mac: sess.opts.debugging_opts.trace_macros,
 293             should_test: sess.opts.test,
 294             ..rustc_expand::expand::ExpansionConfig::default(crate_name.to_string())
 295         };
 296
 297         let mut ecx = ExtCtxt::new(&sess.parse_sess, cfg, &mut resolver);
 298
 299         // Expand macros now!
 300         let krate = sess.time("expand_crate", || ecx.monotonic_expander().expand_crate(krate));
 301
 302         // The rest is error reporting
 303
 304         sess.time("check_unused_macros", || {
 305             ecx.check_unused_macros();
 306         });
 307
 308         let mut missing_fragment_specifiers: Vec<_> =
 309             ecx.parse_sess.missing_fragment_specifiers.borrow().iter().cloned().collect();
 310         missing_fragment_specifiers.sort();
 311
 312         for span in missing_fragment_specifiers {
 313             let lint = lint::builtin::MISSING_FRAGMENT_SPECIFIER;
 314             let msg = "missing fragment specifier";
 315             resolver.lint_buffer().buffer_lint(lint, ast::CRATE_NODE_ID, span, msg);
 316         }
 317         if cfg!(windows) {
 318             env::set_var("PATH", &old_path);
 319         }
 320         krate
 321     });
 322
 323     sess.time("maybe_building_test_harness", || {
 324         rustc_builtin_macros::test_harness::inject(
 325             &sess.parse_sess,
 326             &mut resolver,
 327             sess.opts.test,
 328             &mut krate,
 329             sess.diagnostic(),
 330             &sess.features_untracked(),
 331             sess.panic_strategy(),
 332             sess.target.target.options.panic_strategy,
 333             sess.opts.debugging_opts.panic_abort_tests,
 334         )
 335     });
 336
 337     // If we're actually rustdoc then there's no need to actually compile
 338     // anything, so switch everything to just looping
 339     let mut should_loop = sess.opts.actually_rustdoc;
 340     if let Some(PpMode::PpmSource(PpSourceMode::PpmEveryBodyLoops)) = sess.opts.pretty {
 341         should_loop |= true;
 342     }
 343     if should_loop {
 344         util::ReplaceBodyWithLoop::new(&mut resolver).visit_crate(&mut krate);
 345     }
 346
 347     let has_proc_macro_decls = sess.time("AST_validation", || {
 348         ast_validation::check_crate(sess, &krate, &mut resolver.lint_buffer())
 349     });
 350
 351     let crate_types = sess.crate_types.borrow();
 352     let is_proc_macro_crate = crate_types.contains(&config::CrateType::ProcMacro);
 353
 354     // For backwards compatibility, we don't try to run proc macro injection
 355     // if rustdoc is run on a proc macro crate without '--crate-type proc-macro' being
 356     // specified. This should only affect users who manually invoke 'rustdoc', as
 357     // 'cargo doc' will automatically pass the proper '--crate-type' flags.
 358     // However, we do emit a warning, to let such users know that they should
 359     // start passing '--crate-type proc-macro'
 360     if has_proc_macro_decls && sess.opts.actually_rustdoc && !is_proc_macro_crate {
 361         let mut msg = sess.diagnostic().struct_warn(
 362             &"Trying to document proc macro crate \
 363             without passing '--crate-type proc-macro to rustdoc",
 364         );
 365
 366         msg.warn("The generated documentation may be incorrect");
 367         msg.emit()
 368     } else {
 369         krate = sess.time("maybe_create_a_macro_crate", || {
 370             let num_crate_types = crate_types.len();
 371             let is_test_crate = sess.opts.test;
 372             rustc_builtin_macros::proc_macro_harness::inject(
 373                 &sess.parse_sess,
 374                 &mut resolver,
 375                 krate,
 376                 is_proc_macro_crate,
 377                 has_proc_macro_decls,
 378                 is_test_crate,
 379                 num_crate_types,
 380                 sess.diagnostic(),
 381             )
 382         });
 383     }
 384
 385     // Done with macro expansion!
 386
 387     if sess.opts.debugging_opts.input_stats {
 388         println!("Post-expansion node count: {}", count_nodes(&krate));
 389     }
 390
 391     if sess.opts.debugging_opts.hir_stats {
 392         hir_stats::print_ast_stats(&krate, "POST EXPANSION AST STATS");
 393     }
 394
 395     if sess.opts.debugging_opts.ast_json {
 396         println!("{}", json::as_json(&krate));
 397     }
 398
 399     resolver.resolve_crate(&krate);
 400
 401     // Needs to go *after* expansion to be able to check the results of macro expansion.
 402     sess.time("complete_gated_feature_checking", || {
 403         syntax::feature_gate::check_crate(
 404             &krate,
 405             &sess.parse_sess,
 406             &sess.features_untracked(),
 407             sess.opts.unstable_features,
 408         );
 409     });
 410
 411     // Add all buffered lints from the `ParseSess` to the `Session`.
 412     sess.parse_sess.buffered_lints.with_lock(|buffered_lints| {
 413         info!("{} parse sess buffered_lints", buffered_lints.len());
 414         for BufferedEarlyLint { id, span, msg, lint_id } in buffered_lints.drain(..) {
 415             resolver.lint_buffer().buffer_lint(lint_id, id, span, &msg);
 416         }
 417     });
 418
 419     Ok((krate, resolver))
 420 }
 421
 422 pub fn lower_to_hir<'res, 'tcx>(
 423     sess: &'tcx Session,
 424     lint_store: &lint::LintStore,
 425     resolver: &'res mut Resolver<'_>,
 426     dep_graph: &'res DepGraph,
 427     krate: &'res ast::Crate,
 428     arena: &'tcx Arena<'tcx>,
 429 ) -> Result<map::Forest<'tcx>> {
 430     // Lower AST to HIR.
 431     let hir_crate = rustc_ast_lowering::lower_crate(
 432         sess,
 433         &dep_graph,
 434         &krate,
 435         resolver,
 436         rustc_parse::nt_to_tokenstream,
 437         arena,
 438     );
 439
 440     if sess.opts.debugging_opts.hir_stats {
 441         hir_stats::print_hir_stats(&hir_crate);
 442     }
 443
 444     let hir_forest = map::Forest::new(hir_crate, &dep_graph);
 445
 446     sess.time("early_lint_checks", || {
 447         rustc_lint::check_ast_crate(
 448             sess,
 449             lint_store,
 450             &krate,
 451             false,
 452             Some(std::mem::take(resolver.lint_buffer())),
 453             rustc_lint::BuiltinCombinedEarlyLintPass::new(),
 454         )
 455     });
 456
 457     // Discard hygiene data, which isn't required after lowering to HIR.
 458     if !sess.opts.debugging_opts.keep_hygiene_data {
 459         rustc_span::hygiene::clear_syntax_context_map();
 460     }
 461
 462     Ok(hir_forest)
 463 }
 464
 465 // Returns all the paths that correspond to generated files.
 466 fn generated_output_paths(
 467     sess: &Session,
 468     outputs: &OutputFilenames,
 469     exact_name: bool,
 470     crate_name: &str,
 471 ) -> Vec<PathBuf> {
 472     let mut out_filenames = Vec::new();
 473     for output_type in sess.opts.output_types.keys() {
 474         let file = outputs.path(*output_type);
 475         match *output_type {
 476             // If the filename has been overridden using `-o`, it will not be modified
 477             // by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
 478             OutputType::Exe if !exact_name => {
 479                 for crate_type in sess.crate_types.borrow().iter() {
 480                     let p = ::rustc_codegen_utils::link::filename_for_input(
 481                         sess,
 482                         *crate_type,
 483                         crate_name,
 484                         outputs,
 485                     );
 486                     out_filenames.push(p);
 487                 }
 488             }
 489             OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
 490                 // Don't add the dep-info output when omitting it from dep-info targets
 491             }
 492             _ => {
 493                 out_filenames.push(file);
 494             }
 495         }
 496     }
 497     out_filenames
 498 }
 499
 500 // Runs `f` on every output file path and returns the first non-None result, or None if `f`
 501 // returns None for every file path.
 502 fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
 503 where
 504     F: Fn(&PathBuf) -> Option<T>,
 505 {
 506     for output_path in output_paths {
 507         if let Some(result) = f(output_path) {
 508             return Some(result);
 509         }
 510     }
 511     None
 512 }
 513
 514 fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
 515     let input_path = input_path.canonicalize().ok();
 516     if input_path.is_none() {
 517         return false;
 518     }
 519     let check = |output_path: &PathBuf| {
 520         if output_path.canonicalize().ok() == input_path { Some(()) } else { None }
 521     };
 522     check_output(output_paths, check).is_some()
 523 }
 524
 525 fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
 526     let check = |output_path: &PathBuf| output_path.is_dir().then(|| output_path.clone());
 527     check_output(output_paths, check)
 528 }
 529
 530 fn escape_dep_filename(filename: &FileName) -> String {
 531     // Apparently clang and gcc *only* escape spaces:
 532     // http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
 533     filename.to_string().replace(" ", "\\ ")
 534 }
 535
 536 fn write_out_deps(
 537     sess: &Session,
 538     boxed_resolver: &Steal<Rc<RefCell<BoxedResolver>>>,
 539     outputs: &OutputFilenames,
 540     out_filenames: &[PathBuf],
 541 ) {
 542     // Write out dependency rules to the dep-info file if requested
 543     if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
 544         return;
 545     }
 546     let deps_filename = outputs.path(OutputType::DepInfo);
 547
 548     let result = (|| -> io::Result<()> {
 549         // Build a list of files used to compile the output and
 550         // write Makefile-compatible dependency rules
 551         let mut files: Vec<String> = sess
 552             .source_map()
 553             .files()
 554             .iter()
 555             .filter(|fmap| fmap.is_real_file())
 556             .filter(|fmap| !fmap.is_imported())
 557             .map(|fmap| escape_dep_filename(&fmap.unmapped_path.as_ref().unwrap_or(&fmap.name)))
 558             .collect();
 559
 560         if sess.binary_dep_depinfo() {
 561             boxed_resolver.borrow().borrow_mut().access(|resolver| {
 562                 for cnum in resolver.cstore().crates_untracked() {
 563                     let source = resolver.cstore().crate_source_untracked(cnum);
 564                     if let Some((path, _)) = source.dylib {
 565                         files.push(escape_dep_filename(&FileName::Real(path)));
 566                     }
 567                     if let Some((path, _)) = source.rlib {
 568                         files.push(escape_dep_filename(&FileName::Real(path)));
 569                     }
 570                     if let Some((path, _)) = source.rmeta {
 571                         files.push(escape_dep_filename(&FileName::Real(path)));
 572                     }
 573                 }
 574             });
 575         }
 576
 577         let mut file = fs::File::create(&deps_filename)?;
 578         for path in out_filenames {
 579             writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
 580         }
 581
 582         // Emit a fake target for each input file to the compilation. This
 583         // prevents `make` from spitting out an error if a file is later
 584         // deleted. For more info see #28735
 585         for path in files {
 586             writeln!(file, "{}:", path)?;
 587         }
 588         Ok(())
 589     })();
 590
 591     match result {
 592         Ok(_) => {
 593             if sess.opts.json_artifact_notifications {
 594                 sess.parse_sess
 595                     .span_diagnostic
 596                     .emit_artifact_notification(&deps_filename, "dep-info");
 597             }
 598         }
 599         Err(e) => sess.fatal(&format!(
 600             "error writing dependencies to `{}`: {}",
 601             deps_filename.display(),
 602             e
 603         )),
 604     }
 605 }
 606
 607 pub fn prepare_outputs(
 608     sess: &Session,
 609     compiler: &Compiler,
 610     krate: &ast::Crate,
 611     boxed_resolver: &Steal<Rc<RefCell<BoxedResolver>>>,
 612     crate_name: &str,
 613 ) -> Result<OutputFilenames> {
 614     // FIXME: rustdoc passes &[] instead of &krate.attrs here
 615     let outputs = util::build_output_filenames(
 616         &compiler.input,
 617         &compiler.output_dir,
 618         &compiler.output_file,
 619         &krate.attrs,
 620         sess,
 621     );
 622
 623     let output_paths =
 624         generated_output_paths(sess, &outputs, compiler.output_file.is_some(), &crate_name);
 625
 626     // Ensure the source file isn't accidentally overwritten during compilation.
 627     if let Some(ref input_path) = compiler.input_path {
 628         if sess.opts.will_create_output_file() {
 629             if output_contains_path(&output_paths, input_path) {
 630                 sess.err(&format!(
 631                     "the input file \"{}\" would be overwritten by the generated \
 632                         executable",
 633                     input_path.display()
 634                 ));
 635                 return Err(ErrorReported);
 636             }
 637             if let Some(dir_path) = output_conflicts_with_dir(&output_paths) {
 638                 sess.err(&format!(
 639                     "the generated executable for the input file \"{}\" conflicts with the \
 640                         existing directory \"{}\"",
 641                     input_path.display(),
 642                     dir_path.display()
 643                 ));
 644                 return Err(ErrorReported);
 645             }
 646         }
 647     }
 648
 649     write_out_deps(sess, boxed_resolver, &outputs, &output_paths);
 650
 651     let only_dep_info = sess.opts.output_types.contains_key(&OutputType::DepInfo)
 652         && sess.opts.output_types.len() == 1;
 653
 654     if !only_dep_info {
 655         if let Some(ref dir) = compiler.output_dir {
 656             if fs::create_dir_all(dir).is_err() {
 657                 sess.err("failed to find or create the directory specified by `--out-dir`");
 658                 return Err(ErrorReported);
 659             }
 660         }
 661     }
 662
 663     Ok(outputs)
 664 }
 665
 666 pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
 667     providers.analysis = analysis;
 668     proc_macro_decls::provide(providers);
 669     plugin::build::provide(providers);
 670     rustc::hir::provide(providers);
 671     mir::provide(providers);
 672     rustc_privacy::provide(providers);
 673     typeck::provide(providers);
 674     ty::provide(providers);
 675     traits::provide(providers);
 676     rustc_passes::provide(providers);
 677     rustc_resolve::provide(providers);
 678     rustc_traits::provide(providers);
 679     rustc_metadata::provide(providers);
 680     rustc_lint::provide(providers);
 681     rustc_codegen_utils::provide(providers);
 682     rustc_codegen_ssa::provide(providers);
 683 }
 684
 685 pub fn default_provide_extern(providers: &mut ty::query::Providers<'_>) {
 686     rustc_metadata::provide_extern(providers);
 687     rustc_codegen_ssa::provide_extern(providers);
 688 }
 689
 690 pub struct QueryContext<'tcx>(&'tcx GlobalCtxt<'tcx>);
 691
 692 impl<'tcx> QueryContext<'tcx> {
 693     pub fn enter<F, R>(&mut self, f: F) -> R
 694     where
 695         F: FnOnce(TyCtxt<'tcx>) -> R,
 696     {
 697         ty::tls::enter_global(self.0, |tcx| f(tcx))
 698     }
 699
 700     pub fn print_stats(&self) {
 701         self.0.queries.print_stats()
 702     }
 703 }
 704
 705 pub fn create_global_ctxt<'tcx>(
 706     compiler: &'tcx Compiler,
 707     lint_store: Lrc<lint::LintStore>,
 708     hir_forest: &'tcx map::Forest<'tcx>,
 709     mut resolver_outputs: ResolverOutputs,
 710     outputs: OutputFilenames,
 711     crate_name: &str,
 712     global_ctxt: &'tcx Once<GlobalCtxt<'tcx>>,
 713     all_arenas: &'tcx AllArenas,
 714     arena: &'tcx WorkerLocal<Arena<'tcx>>,
 715 ) -> QueryContext<'tcx> {
 716     let sess = &compiler.session();
 717     let defs = mem::take(&mut resolver_outputs.definitions);
 718
 719     // Construct the HIR map.
 720     let hir_map = map::map_crate(sess, &*resolver_outputs.cstore, &hir_forest, defs);
 721
 722     let query_result_on_disk_cache = rustc_incremental::load_query_result_cache(sess);
 723
 724     let codegen_backend = compiler.codegen_backend();
 725     let mut local_providers = ty::query::Providers::default();
 726     default_provide(&mut local_providers);
 727     codegen_backend.provide(&mut local_providers);
 728
 729     let mut extern_providers = local_providers;
 730     default_provide_extern(&mut extern_providers);
 731     codegen_backend.provide_extern(&mut extern_providers);
 732
 733     if let Some(callback) = compiler.override_queries {
 734         callback(sess, &mut local_providers, &mut extern_providers);
 735     }
 736
 737     let gcx = global_ctxt.init_locking(|| {
 738         TyCtxt::create_global_ctxt(
 739             sess,
 740             lint_store,
 741             local_providers,
 742             extern_providers,
 743             &all_arenas,
 744             arena,
 745             resolver_outputs,
 746             hir_map,
 747             query_result_on_disk_cache,
 748             &crate_name,
 749             &outputs,
 750         )
 751     });
 752
 753     // Do some initialization of the DepGraph that can only be done with the tcx available.
 754     ty::tls::enter_global(&gcx, |tcx| {
 755         tcx.sess.time("dep_graph_tcx_init", || rustc_incremental::dep_graph_tcx_init(tcx));
 756     });
 757
 758     QueryContext(gcx)
 759 }
 760
 761 /// Runs the resolution, type-checking, region checking and other
 762 /// miscellaneous analysis passes on the crate.
 763 fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
 764     assert_eq!(cnum, LOCAL_CRATE);
 765
 766     let sess = tcx.sess;
 767     let mut entry_point = None;
 768
 769     sess.time("misc_checking_1", || {
 770         parallel!(
 771             {
 772                 entry_point = sess
 773                     .time("looking_for_entry_point", || rustc_passes::entry::find_entry_point(tcx));
 774
 775                 sess.time("looking_for_plugin_registrar", || {
 776                     plugin::build::find_plugin_registrar(tcx)
 777                 });
 778
 779                 sess.time("looking_for_derive_registrar", || proc_macro_decls::find(tcx));
 780             },
 781             {
 782                 par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 783                     let local_def_id = tcx.hir().local_def_id(module);
 784                     tcx.ensure().check_mod_loops(local_def_id);
 785                     tcx.ensure().check_mod_attrs(local_def_id);
 786                     tcx.ensure().check_mod_unstable_api_usage(local_def_id);
 787                     tcx.ensure().check_mod_const_bodies(local_def_id);
 788                 });
 789             }
 790         );
 791     });
 792
 793     // passes are timed inside typeck
 794     typeck::check_crate(tcx)?;
 795
 796     sess.time("misc_checking_2", || {
 797         parallel!(
 798             {
 799                 sess.time("match_checking", || {
 800                     tcx.par_body_owners(|def_id| {
 801                         tcx.ensure().check_match(def_id);
 802                     });
 803                 });
 804             },
 805             {
 806                 sess.time("liveness_and_intrinsic_checking", || {
 807                     par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 808                         // this must run before MIR dump, because
 809                         // "not all control paths return a value" is reported here.
 810                         //
 811                         // maybe move the check to a MIR pass?
 812                         let local_def_id = tcx.hir().local_def_id(module);
 813
 814                         tcx.ensure().check_mod_liveness(local_def_id);
 815                         tcx.ensure().check_mod_intrinsics(local_def_id);
 816                     });
 817                 });
 818             }
 819         );
 820     });
 821
 822     sess.time("MIR_borrow_checking", || {
 823         tcx.par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
 824     });
 825
 826     sess.time("dumping_chalk_like_clauses", || {
 827         rustc_traits::lowering::dump_program_clauses(tcx);
 828     });
 829
 830     sess.time("MIR_effect_checking", || {
 831         for def_id in tcx.body_owners() {
 832             mir::transform::check_unsafety::check_unsafety(tcx, def_id)
 833         }
 834     });
 835
 836     sess.time("layout_testing", || layout_test::test_layout(tcx));
 837
 838     // Avoid overwhelming user with errors if borrow checking failed.
 839     // I'm not sure how helpful this is, to be honest, but it avoids a
 840     // lot of annoying errors in the compile-fail tests (basically,
 841     // lint warnings and so on -- kindck used to do this abort, but
 842     // kindck is gone now). -nmatsakis
 843     if sess.has_errors() {
 844         return Err(ErrorReported);
 845     }
 846
 847     sess.time("misc_checking_3", || {
 848         parallel!(
 849             {
 850                 tcx.ensure().privacy_access_levels(LOCAL_CRATE);
 851
 852                 parallel!(
 853                     {
 854                         tcx.ensure().check_private_in_public(LOCAL_CRATE);
 855                     },
 856                     {
 857                         sess.time("death_checking", || rustc_passes::dead::check_crate(tcx));
 858                     },
 859                     {
 860                         sess.time("unused_lib_feature_checking", || {
 861                             rustc_passes::stability::check_unused_or_stable_features(tcx)
 862                         });
 863                     },
 864                     {
 865                         sess.time("lint_checking", || {
 866                             rustc_lint::check_crate(tcx, || {
 867                                 rustc_lint::BuiltinCombinedLateLintPass::new()
 868                             });
 869                         });
 870                     }
 871                 );
 872             },
 873             {
 874                 sess.time("privacy_checking_modules", || {
 875                     par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 876                         tcx.ensure().check_mod_privacy(tcx.hir().local_def_id(module));
 877                     });
 878                 });
 879             }
 880         );
 881     });
 882
 883     Ok(())
 884 }
 885
 886 fn encode_and_write_metadata(
 887     tcx: TyCtxt<'_>,
 888     outputs: &OutputFilenames,
 889 ) -> (middle::cstore::EncodedMetadata, bool) {
 890     #[derive(PartialEq, Eq, PartialOrd, Ord)]
 891     enum MetadataKind {
 892         None,
 893         Uncompressed,
 894         Compressed,
 895     }
 896
 897     let metadata_kind = tcx
 898         .sess
 899         .crate_types
 900         .borrow()
 901         .iter()
 902         .map(|ty| match *ty {
 903             CrateType::Executable | CrateType::Staticlib | CrateType::Cdylib => MetadataKind::None,
 904
 905             CrateType::Rlib => MetadataKind::Uncompressed,
 906
 907             CrateType::Dylib | CrateType::ProcMacro => MetadataKind::Compressed,
 908         })
 909         .max()
 910         .unwrap_or(MetadataKind::None);
 911
 912     let metadata = match metadata_kind {
 913         MetadataKind::None => middle::cstore::EncodedMetadata::new(),
 914         MetadataKind::Uncompressed | MetadataKind::Compressed => tcx.encode_metadata(),
 915     };
 916
 917     let _prof_timer = tcx.sess.prof.generic_activity("write_crate_metadata");
 918
 919     let need_metadata_file = tcx.sess.opts.output_types.contains_key(&OutputType::Metadata);
 920     if need_metadata_file {
 921         let crate_name = &tcx.crate_name(LOCAL_CRATE).as_str();
 922         let out_filename = filename_for_metadata(tcx.sess, crate_name, outputs);
 923         // To avoid races with another rustc process scanning the output directory,
 924         // we need to write the file somewhere else and atomically move it to its
 925         // final destination, with an `fs::rename` call. In order for the rename to
 926         // always succeed, the temporary file needs to be on the same filesystem,
 927         // which is why we create it inside the output directory specifically.
 928         let metadata_tmpdir = TempFileBuilder::new()
 929             .prefix("rmeta")
 930             .tempdir_in(out_filename.parent().unwrap())
 931             .unwrap_or_else(|err| tcx.sess.fatal(&format!("couldn't create a temp dir: {}", err)));
 932         let metadata_filename = emit_metadata(tcx.sess, &metadata, &metadata_tmpdir);
 933         if let Err(e) = fs::rename(&metadata_filename, &out_filename) {
 934             tcx.sess.fatal(&format!("failed to write {}: {}", out_filename.display(), e));
 935         }
 936         if tcx.sess.opts.json_artifact_notifications {
 937             tcx.sess
 938                 .parse_sess
 939                 .span_diagnostic
 940                 .emit_artifact_notification(&out_filename, "metadata");
 941         }
 942     }
 943
 944     let need_metadata_module = metadata_kind == MetadataKind::Compressed;
 945
 946     (metadata, need_metadata_module)
 947 }
 948
 949 /// Runs the codegen backend, after which the AST and analysis can
 950 /// be discarded.
 951 pub fn start_codegen<'tcx>(
 952     codegen_backend: &dyn CodegenBackend,
 953     tcx: TyCtxt<'tcx>,
 954     outputs: &OutputFilenames,
 955 ) -> Box<dyn Any> {
 956     if log_enabled!(::log::Level::Info) {
 957         println!("Pre-codegen");
 958         tcx.print_debug_stats();
 959     }
 960
 961     let (metadata, need_metadata_module) = encode_and_write_metadata(tcx, outputs);
 962
 963     let codegen = tcx.sess.time("codegen_crate", move || {
 964         codegen_backend.codegen_crate(tcx, metadata, need_metadata_module)
 965     });
 966
 967     if log_enabled!(::log::Level::Info) {
 968         println!("Post-codegen");
 969         tcx.print_debug_stats();
 970     }
 971
 972     if tcx.sess.opts.output_types.contains_key(&OutputType::Mir) {
 973         if let Err(e) = mir::transform::dump_mir::emit_mir(tcx, outputs) {
 974             tcx.sess.err(&format!("could not emit MIR: {}", e));
 975             tcx.sess.abort_if_errors();
 976         }
 977     }
 978
 979     codegen
 980 }