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