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