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