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