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