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, RealFileName};
  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             span_debug: sess.opts.debugging_opts.span_debug,
 295             ..rustc_expand::expand::ExpansionConfig::default(crate_name.to_string())
 296         };
 297
 298         let extern_mod_loaded = |k: &ast::Crate| pre_expansion_lint(sess, lint_store, k);
 299         let mut ecx = ExtCtxt::new(&sess.parse_sess, cfg, &mut resolver, Some(&extern_mod_loaded));
 300
 301         // Expand macros now!
 302         let krate = sess.time("expand_crate", || ecx.monotonic_expander().expand_crate(krate));
 303
 304         // The rest is error reporting
 305
 306         sess.time("check_unused_macros", || {
 307             ecx.check_unused_macros();
 308         });
 309
 310         let mut missing_fragment_specifiers: Vec<_> =
 311             ecx.parse_sess.missing_fragment_specifiers.borrow().iter().cloned().collect();
 312         missing_fragment_specifiers.sort();
 313
 314         let recursion_limit_hit = ecx.reduced_recursion_limit.is_some();
 315
 316         for span in missing_fragment_specifiers {
 317             let lint = lint::builtin::MISSING_FRAGMENT_SPECIFIER;
 318             let msg = "missing fragment specifier";
 319             resolver.lint_buffer().buffer_lint(lint, ast::CRATE_NODE_ID, span, msg);
 320         }
 321         if cfg!(windows) {
 322             env::set_var("PATH", &old_path);
 323         }
 324
 325         if recursion_limit_hit {
 326             // If we hit a recursion limit, exit early to avoid later passes getting overwhelmed
 327             // with a large AST
 328             Err(ErrorReported)
 329         } else {
 330             Ok(krate)
 331         }
 332     })?;
 333
 334     sess.time("maybe_building_test_harness", || {
 335         rustc_builtin_macros::test_harness::inject(
 336             &sess.parse_sess,
 337             &mut resolver,
 338             sess.opts.test,
 339             &mut krate,
 340             sess.diagnostic(),
 341             &sess.features_untracked(),
 342             sess.panic_strategy(),
 343             sess.target.target.options.panic_strategy,
 344             sess.opts.debugging_opts.panic_abort_tests,
 345         )
 346     });
 347
 348     // If we're actually rustdoc then there's no need to actually compile
 349     // anything, so switch everything to just looping
 350     let mut should_loop = sess.opts.actually_rustdoc;
 351     if let Some(PpMode::PpmSource(PpSourceMode::PpmEveryBodyLoops)) = sess.opts.pretty {
 352         should_loop |= true;
 353     }
 354     if should_loop {
 355         util::ReplaceBodyWithLoop::new(&mut resolver).visit_crate(&mut krate);
 356     }
 357
 358     let has_proc_macro_decls = sess.time("AST_validation", || {
 359         rustc_ast_passes::ast_validation::check_crate(sess, &krate, &mut resolver.lint_buffer())
 360     });
 361
 362     let crate_types = sess.crate_types();
 363     let is_proc_macro_crate = crate_types.contains(&CrateType::ProcMacro);
 364
 365     // For backwards compatibility, we don't try to run proc macro injection
 366     // if rustdoc is run on a proc macro crate without '--crate-type proc-macro' being
 367     // specified. This should only affect users who manually invoke 'rustdoc', as
 368     // 'cargo doc' will automatically pass the proper '--crate-type' flags.
 369     // However, we do emit a warning, to let such users know that they should
 370     // start passing '--crate-type proc-macro'
 371     if has_proc_macro_decls && sess.opts.actually_rustdoc && !is_proc_macro_crate {
 372         let mut msg = sess.diagnostic().struct_warn(
 373             &"Trying to document proc macro crate \
 374             without passing '--crate-type proc-macro to rustdoc",
 375         );
 376
 377         msg.warn("The generated documentation may be incorrect");
 378         msg.emit()
 379     } else {
 380         krate = sess.time("maybe_create_a_macro_crate", || {
 381             let num_crate_types = crate_types.len();
 382             let is_test_crate = sess.opts.test;
 383             rustc_builtin_macros::proc_macro_harness::inject(
 384                 &sess.parse_sess,
 385                 &mut resolver,
 386                 krate,
 387                 is_proc_macro_crate,
 388                 has_proc_macro_decls,
 389                 is_test_crate,
 390                 num_crate_types,
 391                 sess.diagnostic(),
 392             )
 393         });
 394     }
 395
 396     // Done with macro expansion!
 397
 398     if sess.opts.debugging_opts.input_stats {
 399         println!("Post-expansion node count: {}", count_nodes(&krate));
 400     }
 401
 402     if sess.opts.debugging_opts.hir_stats {
 403         hir_stats::print_ast_stats(&krate, "POST EXPANSION AST STATS");
 404     }
 405
 406     if sess.opts.debugging_opts.ast_json {
 407         println!("{}", json::as_json(&krate));
 408     }
 409
 410     resolver.resolve_crate(&krate);
 411
 412     // Needs to go *after* expansion to be able to check the results of macro expansion.
 413     sess.time("complete_gated_feature_checking", || {
 414         rustc_ast_passes::feature_gate::check_crate(
 415             &krate,
 416             &sess.parse_sess,
 417             &sess.features_untracked(),
 418             sess.opts.unstable_features,
 419         );
 420     });
 421
 422     // Add all buffered lints from the `ParseSess` to the `Session`.
 423     sess.parse_sess.buffered_lints.with_lock(|buffered_lints| {
 424         info!("{} parse sess buffered_lints", buffered_lints.len());
 425         for early_lint in buffered_lints.drain(..) {
 426             resolver.lint_buffer().add_early_lint(early_lint);
 427         }
 428     });
 429
 430     Ok((krate, resolver))
 431 }
 432
 433 pub fn lower_to_hir<'res, 'tcx>(
 434     sess: &'tcx Session,
 435     lint_store: &LintStore,
 436     resolver: &'res mut Resolver<'_>,
 437     dep_graph: &'res DepGraph,
 438     krate: &'res ast::Crate,
 439     arena: &'tcx rustc_ast_lowering::Arena<'tcx>,
 440 ) -> Crate<'tcx> {
 441     // We're constructing the HIR here; we don't care what we will
 442     // read, since we haven't even constructed the *input* to
 443     // incr. comp. yet.
 444     dep_graph.assert_ignored();
 445
 446     // Lower AST to HIR.
 447     let hir_crate = rustc_ast_lowering::lower_crate(
 448         sess,
 449         &krate,
 450         resolver,
 451         rustc_parse::nt_to_tokenstream,
 452         arena,
 453     );
 454
 455     if sess.opts.debugging_opts.hir_stats {
 456         hir_stats::print_hir_stats(&hir_crate);
 457     }
 458
 459     sess.time("early_lint_checks", || {
 460         rustc_lint::check_ast_crate(
 461             sess,
 462             lint_store,
 463             &krate,
 464             false,
 465             Some(std::mem::take(resolver.lint_buffer())),
 466             rustc_lint::BuiltinCombinedEarlyLintPass::new(),
 467         )
 468     });
 469
 470     // Discard hygiene data, which isn't required after lowering to HIR.
 471     if !sess.opts.debugging_opts.keep_hygiene_data {
 472         rustc_span::hygiene::clear_syntax_context_map();
 473     }
 474
 475     hir_crate
 476 }
 477
 478 // Returns all the paths that correspond to generated files.
 479 fn generated_output_paths(
 480     sess: &Session,
 481     outputs: &OutputFilenames,
 482     exact_name: bool,
 483     crate_name: &str,
 484 ) -> Vec<PathBuf> {
 485     let mut out_filenames = Vec::new();
 486     for output_type in sess.opts.output_types.keys() {
 487         let file = outputs.path(*output_type);
 488         match *output_type {
 489             // If the filename has been overridden using `-o`, it will not be modified
 490             // by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
 491             OutputType::Exe if !exact_name => {
 492                 for crate_type in sess.crate_types().iter() {
 493                     let p = filename_for_input(sess, *crate_type, crate_name, outputs);
 494                     out_filenames.push(p);
 495                 }
 496             }
 497             OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
 498                 // Don't add the dep-info output when omitting it from dep-info targets
 499             }
 500             _ => {
 501                 out_filenames.push(file);
 502             }
 503         }
 504     }
 505     out_filenames
 506 }
 507
 508 // Runs `f` on every output file path and returns the first non-None result, or None if `f`
 509 // returns None for every file path.
 510 fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
 511 where
 512     F: Fn(&PathBuf) -> Option<T>,
 513 {
 514     for output_path in output_paths {
 515         if let Some(result) = f(output_path) {
 516             return Some(result);
 517         }
 518     }
 519     None
 520 }
 521
 522 fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
 523     let input_path = input_path.canonicalize().ok();
 524     if input_path.is_none() {
 525         return false;
 526     }
 527     let check = |output_path: &PathBuf| {
 528         if output_path.canonicalize().ok() == input_path { Some(()) } else { None }
 529     };
 530     check_output(output_paths, check).is_some()
 531 }
 532
 533 fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
 534     let check = |output_path: &PathBuf| output_path.is_dir().then(|| output_path.clone());
 535     check_output(output_paths, check)
 536 }
 537
 538 fn escape_dep_filename(filename: &FileName) -> String {
 539     // Apparently clang and gcc *only* escape spaces:
 540     // http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
 541     filename.to_string().replace(" ", "\\ ")
 542 }
 543
 544 fn write_out_deps(
 545     sess: &Session,
 546     boxed_resolver: &Steal<Rc<RefCell<BoxedResolver>>>,
 547     outputs: &OutputFilenames,
 548     out_filenames: &[PathBuf],
 549 ) {
 550     // Write out dependency rules to the dep-info file if requested
 551     if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
 552         return;
 553     }
 554     let deps_filename = outputs.path(OutputType::DepInfo);
 555
 556     let result = (|| -> io::Result<()> {
 557         // Build a list of files used to compile the output and
 558         // write Makefile-compatible dependency rules
 559         let mut files: Vec<String> = sess
 560             .source_map()
 561             .files()
 562             .iter()
 563             .filter(|fmap| fmap.is_real_file())
 564             .filter(|fmap| !fmap.is_imported())
 565             .map(|fmap| escape_dep_filename(&fmap.unmapped_path.as_ref().unwrap_or(&fmap.name)))
 566             .collect();
 567
 568         if sess.binary_dep_depinfo() {
 569             boxed_resolver.borrow().borrow_mut().access(|resolver| {
 570                 for cnum in resolver.cstore().crates_untracked() {
 571                     let source = resolver.cstore().crate_source_untracked(cnum);
 572                     if let Some((path, _)) = source.dylib {
 573                         let file_name = FileName::Real(RealFileName::Named(path));
 574                         files.push(escape_dep_filename(&file_name));
 575                     }
 576                     if let Some((path, _)) = source.rlib {
 577                         let file_name = FileName::Real(RealFileName::Named(path));
 578                         files.push(escape_dep_filename(&file_name));
 579                     }
 580                     if let Some((path, _)) = source.rmeta {
 581                         let file_name = FileName::Real(RealFileName::Named(path));
 582                         files.push(escape_dep_filename(&file_name));
 583                     }
 584                 }
 585             });
 586         }
 587
 588         let mut file = BufWriter::new(fs::File::create(&deps_filename)?);
 589         for path in out_filenames {
 590             writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
 591         }
 592
 593         // Emit a fake target for each input file to the compilation. This
 594         // prevents `make` from spitting out an error if a file is later
 595         // deleted. For more info see #28735
 596         for path in files {
 597             writeln!(file, "{}:", path)?;
 598         }
 599         Ok(())
 600     })();
 601
 602     match result {
 603         Ok(_) => {
 604             if sess.opts.json_artifact_notifications {
 605                 sess.parse_sess
 606                     .span_diagnostic
 607                     .emit_artifact_notification(&deps_filename, "dep-info");
 608             }
 609         }
 610         Err(e) => sess.fatal(&format!(
 611             "error writing dependencies to `{}`: {}",
 612             deps_filename.display(),
 613             e
 614         )),
 615     }
 616 }
 617
 618 pub fn prepare_outputs(
 619     sess: &Session,
 620     compiler: &Compiler,
 621     krate: &ast::Crate,
 622     boxed_resolver: &Steal<Rc<RefCell<BoxedResolver>>>,
 623     crate_name: &str,
 624 ) -> Result<OutputFilenames> {
 625     let _timer = sess.timer("prepare_outputs");
 626
 627     // FIXME: rustdoc passes &[] instead of &krate.attrs here
 628     let outputs = util::build_output_filenames(
 629         &compiler.input,
 630         &compiler.output_dir,
 631         &compiler.output_file,
 632         &krate.attrs,
 633         sess,
 634     );
 635
 636     let output_paths =
 637         generated_output_paths(sess, &outputs, compiler.output_file.is_some(), &crate_name);
 638
 639     // Ensure the source file isn't accidentally overwritten during compilation.
 640     if let Some(ref input_path) = compiler.input_path {
 641         if sess.opts.will_create_output_file() {
 642             if output_contains_path(&output_paths, input_path) {
 643                 sess.err(&format!(
 644                     "the input file \"{}\" would be overwritten by the generated \
 645                         executable",
 646                     input_path.display()
 647                 ));
 648                 return Err(ErrorReported);
 649             }
 650             if let Some(dir_path) = output_conflicts_with_dir(&output_paths) {
 651                 sess.err(&format!(
 652                     "the generated executable for the input file \"{}\" conflicts with the \
 653                         existing directory \"{}\"",
 654                     input_path.display(),
 655                     dir_path.display()
 656                 ));
 657                 return Err(ErrorReported);
 658             }
 659         }
 660     }
 661
 662     write_out_deps(sess, boxed_resolver, &outputs, &output_paths);
 663
 664     let only_dep_info = sess.opts.output_types.contains_key(&OutputType::DepInfo)
 665         && sess.opts.output_types.len() == 1;
 666
 667     if !only_dep_info {
 668         if let Some(ref dir) = compiler.output_dir {
 669             if fs::create_dir_all(dir).is_err() {
 670                 sess.err("failed to find or create the directory specified by `--out-dir`");
 671                 return Err(ErrorReported);
 672             }
 673         }
 674     }
 675
 676     Ok(outputs)
 677 }
 678
 679 pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
 680     providers.analysis = analysis;
 681     proc_macro_decls::provide(providers);
 682     plugin::build::provide(providers);
 683     rustc_middle::hir::provide(providers);
 684     mir::provide(providers);
 685     mir_build::provide(providers);
 686     rustc_privacy::provide(providers);
 687     typeck::provide(providers);
 688     ty::provide(providers);
 689     traits::provide(providers);
 690     rustc_passes::provide(providers);
 691     rustc_resolve::provide(providers);
 692     rustc_traits::provide(providers);
 693     rustc_ty::provide(providers);
 694     rustc_metadata::provide(providers);
 695     rustc_lint::provide(providers);
 696     rustc_symbol_mangling::provide(providers);
 697     rustc_codegen_ssa::provide(providers);
 698 }
 699
 700 pub fn default_provide_extern(providers: &mut ty::query::Providers<'_>) {
 701     rustc_metadata::provide_extern(providers);
 702     rustc_codegen_ssa::provide_extern(providers);
 703 }
 704
 705 pub struct QueryContext<'tcx>(&'tcx GlobalCtxt<'tcx>);
 706
 707 impl<'tcx> QueryContext<'tcx> {
 708     pub fn enter<F, R>(&mut self, f: F) -> R
 709     where
 710         F: FnOnce(TyCtxt<'tcx>) -> R,
 711     {
 712         ty::tls::enter_global(self.0, f)
 713     }
 714
 715     pub fn print_stats(&mut self) {
 716         self.enter(ty::query::print_stats)
 717     }
 718 }
 719
 720 pub fn create_global_ctxt<'tcx>(
 721     compiler: &'tcx Compiler,
 722     lint_store: Lrc<LintStore>,
 723     krate: &'tcx Crate<'tcx>,
 724     dep_graph: DepGraph,
 725     mut resolver_outputs: ResolverOutputs,
 726     outputs: OutputFilenames,
 727     crate_name: &str,
 728     global_ctxt: &'tcx OnceCell<GlobalCtxt<'tcx>>,
 729     arena: &'tcx WorkerLocal<Arena<'tcx>>,
 730 ) -> QueryContext<'tcx> {
 731     let sess = &compiler.session();
 732     let defs: &'tcx Definitions = arena.alloc(mem::take(&mut resolver_outputs.definitions));
 733
 734     let query_result_on_disk_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 = sess.time("setup_global_ctxt", || {
 750         global_ctxt.get_or_init(|| {
 751             TyCtxt::create_global_ctxt(
 752                 sess,
 753                 lint_store,
 754                 local_providers,
 755                 extern_providers,
 756                 arena,
 757                 resolver_outputs,
 758                 krate,
 759                 defs,
 760                 dep_graph,
 761                 query_result_on_disk_cache,
 762                 &crate_name,
 763                 &outputs,
 764             )
 765         })
 766     });
 767
 768     // Do some initialization of the DepGraph that can only be done with the tcx available.
 769     ty::tls::enter_global(&gcx, |tcx| {
 770         tcx.sess.time("dep_graph_tcx_init", || rustc_incremental::dep_graph_tcx_init(tcx));
 771     });
 772
 773     QueryContext(gcx)
 774 }
 775
 776 /// Runs the resolution, type-checking, region checking and other
 777 /// miscellaneous analysis passes on the crate.
 778 fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
 779     assert_eq!(cnum, LOCAL_CRATE);
 780
 781     rustc_passes::hir_id_validator::check_crate(tcx);
 782
 783     let sess = tcx.sess;
 784     let mut entry_point = None;
 785
 786     sess.time("misc_checking_1", || {
 787         parallel!(
 788             {
 789                 entry_point = sess
 790                     .time("looking_for_entry_point", || rustc_passes::entry::find_entry_point(tcx));
 791
 792                 sess.time("looking_for_plugin_registrar", || {
 793                     plugin::build::find_plugin_registrar(tcx)
 794                 });
 795
 796                 sess.time("looking_for_derive_registrar", || proc_macro_decls::find(tcx));
 797             },
 798             {
 799                 par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 800                     let local_def_id = tcx.hir().local_def_id(module);
 801                     tcx.ensure().check_mod_loops(local_def_id);
 802                     tcx.ensure().check_mod_attrs(local_def_id);
 803                     tcx.ensure().check_mod_unstable_api_usage(local_def_id);
 804                     tcx.ensure().check_mod_const_bodies(local_def_id);
 805                 });
 806             }
 807         );
 808     });
 809
 810     // passes are timed inside typeck
 811     typeck::check_crate(tcx)?;
 812
 813     sess.time("misc_checking_2", || {
 814         parallel!(
 815             {
 816                 sess.time("match_checking", || {
 817                     tcx.par_body_owners(|def_id| {
 818                         tcx.ensure().check_match(def_id.to_def_id());
 819                     });
 820                 });
 821             },
 822             {
 823                 sess.time("liveness_and_intrinsic_checking", || {
 824                     par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 825                         // this must run before MIR dump, because
 826                         // "not all control paths return a value" is reported here.
 827                         //
 828                         // maybe move the check to a MIR pass?
 829                         let local_def_id = tcx.hir().local_def_id(module);
 830
 831                         tcx.ensure().check_mod_liveness(local_def_id);
 832                         tcx.ensure().check_mod_intrinsics(local_def_id);
 833                     });
 834                 });
 835             }
 836         );
 837     });
 838
 839     sess.time("MIR_borrow_checking", || {
 840         tcx.par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
 841     });
 842
 843     sess.time("MIR_effect_checking", || {
 844         for def_id in tcx.body_owners() {
 845             mir::transform::check_unsafety::check_unsafety(tcx, def_id)
 846         }
 847     });
 848
 849     sess.time("layout_testing", || layout_test::test_layout(tcx));
 850
 851     // Avoid overwhelming user with errors if borrow checking failed.
 852     // I'm not sure how helpful this is, to be honest, but it avoids a
 853     // lot of annoying errors in the compile-fail tests (basically,
 854     // lint warnings and so on -- kindck used to do this abort, but
 855     // kindck is gone now). -nmatsakis
 856     if sess.has_errors() {
 857         return Err(ErrorReported);
 858     }
 859
 860     sess.time("misc_checking_3", || {
 861         parallel!(
 862             {
 863                 tcx.ensure().privacy_access_levels(LOCAL_CRATE);
 864
 865                 parallel!(
 866                     {
 867                         tcx.ensure().check_private_in_public(LOCAL_CRATE);
 868                     },
 869                     {
 870                         sess.time("death_checking", || rustc_passes::dead::check_crate(tcx));
 871                     },
 872                     {
 873                         sess.time("unused_lib_feature_checking", || {
 874                             rustc_passes::stability::check_unused_or_stable_features(tcx)
 875                         });
 876                     },
 877                     {
 878                         sess.time("lint_checking", || {
 879                             rustc_lint::check_crate(tcx, || {
 880                                 rustc_lint::BuiltinCombinedLateLintPass::new()
 881                             });
 882                         });
 883                     }
 884                 );
 885             },
 886             {
 887                 sess.time("privacy_checking_modules", || {
 888                     par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {
 889                         tcx.ensure().check_mod_privacy(tcx.hir().local_def_id(module));
 890                     });
 891                 });
 892             }
 893         );
 894     });
 895
 896     Ok(())
 897 }
 898
 899 fn encode_and_write_metadata(
 900     tcx: TyCtxt<'_>,
 901     outputs: &OutputFilenames,
 902 ) -> (middle::cstore::EncodedMetadata, bool) {
 903     #[derive(PartialEq, Eq, PartialOrd, Ord)]
 904     enum MetadataKind {
 905         None,
 906         Uncompressed,
 907         Compressed,
 908     }
 909
 910     let metadata_kind = tcx
 911         .sess
 912         .crate_types()
 913         .iter()
 914         .map(|ty| match *ty {
 915             CrateType::Executable | CrateType::Staticlib | CrateType::Cdylib => MetadataKind::None,
 916
 917             CrateType::Rlib => MetadataKind::Uncompressed,
 918
 919             CrateType::Dylib | CrateType::ProcMacro => MetadataKind::Compressed,
 920         })
 921         .max()
 922         .unwrap_or(MetadataKind::None);
 923
 924     let metadata = match metadata_kind {
 925         MetadataKind::None => middle::cstore::EncodedMetadata::new(),
 926         MetadataKind::Uncompressed | MetadataKind::Compressed => tcx.encode_metadata(),
 927     };
 928
 929     let _prof_timer = tcx.sess.prof.generic_activity("write_crate_metadata");
 930
 931     let need_metadata_file = tcx.sess.opts.output_types.contains_key(&OutputType::Metadata);
 932     if need_metadata_file {
 933         let crate_name = &tcx.crate_name(LOCAL_CRATE).as_str();
 934         let out_filename = filename_for_metadata(tcx.sess, crate_name, outputs);
 935         // To avoid races with another rustc process scanning the output directory,
 936         // we need to write the file somewhere else and atomically move it to its
 937         // final destination, with an `fs::rename` call. In order for the rename to
 938         // always succeed, the temporary file needs to be on the same filesystem,
 939         // which is why we create it inside the output directory specifically.
 940         let metadata_tmpdir = TempFileBuilder::new()
 941             .prefix("rmeta")
 942             .tempdir_in(out_filename.parent().unwrap())
 943             .unwrap_or_else(|err| tcx.sess.fatal(&format!("couldn't create a temp dir: {}", err)));
 944         let metadata_filename = emit_metadata(tcx.sess, &metadata, &metadata_tmpdir);
 945         if let Err(e) = fs::rename(&metadata_filename, &out_filename) {
 946             tcx.sess.fatal(&format!("failed to write {}: {}", out_filename.display(), e));
 947         }
 948         if tcx.sess.opts.json_artifact_notifications {
 949             tcx.sess
 950                 .parse_sess
 951                 .span_diagnostic
 952                 .emit_artifact_notification(&out_filename, "metadata");
 953         }
 954     }
 955
 956     let need_metadata_module = metadata_kind == MetadataKind::Compressed;
 957
 958     (metadata, need_metadata_module)
 959 }
 960
 961 /// Runs the codegen backend, after which the AST and analysis can
 962 /// be discarded.
 963 pub fn start_codegen<'tcx>(
 964     codegen_backend: &dyn CodegenBackend,
 965     tcx: TyCtxt<'tcx>,
 966     outputs: &OutputFilenames,
 967 ) -> Box<dyn Any> {
 968     if log_enabled!(::log::Level::Info) {
 969         println!("Pre-codegen");
 970         tcx.print_debug_stats();
 971     }
 972
 973     let (metadata, need_metadata_module) = encode_and_write_metadata(tcx, outputs);
 974
 975     let codegen = tcx.sess.time("codegen_crate", move || {
 976         codegen_backend.codegen_crate(tcx, metadata, need_metadata_module)
 977     });
 978
 979     if log_enabled!(::log::Level::Info) {
 980         println!("Post-codegen");
 981         tcx.print_debug_stats();
 982     }
 983
 984     if tcx.sess.opts.output_types.contains_key(&OutputType::Mir) {
 985         if let Err(e) = mir::transform::dump_mir::emit_mir(tcx, outputs) {
 986             tcx.sess.err(&format!("could not emit MIR: {}", e));
 987             tcx.sess.abort_if_errors();
 988         }
 989     }
 990
 991     codegen
 992 }