mirror of
https://github.com/rust-lang/rust.git
synced 2024-10-29 21:41:47 +00:00
Introduce rustc_interface and move some methods there
This commit is contained in:
parent
1999a22881
commit
23a51f91c9
31
Cargo.lock
31
Cargo.lock
@ -2699,6 +2699,7 @@ dependencies = [
|
||||
"rustc_data_structures 0.0.0",
|
||||
"rustc_errors 0.0.0",
|
||||
"rustc_incremental 0.0.0",
|
||||
"rustc_interface 0.0.0",
|
||||
"rustc_lint 0.0.0",
|
||||
"rustc_metadata 0.0.0",
|
||||
"rustc_mir 0.0.0",
|
||||
@ -2751,6 +2752,36 @@ dependencies = [
|
||||
"syntax_pos 0.0.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc_interface"
|
||||
version = "0.0.0"
|
||||
dependencies = [
|
||||
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"rustc 0.0.0",
|
||||
"rustc-rayon 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"rustc_allocator 0.0.0",
|
||||
"rustc_borrowck 0.0.0",
|
||||
"rustc_codegen_utils 0.0.0",
|
||||
"rustc_data_structures 0.0.0",
|
||||
"rustc_errors 0.0.0",
|
||||
"rustc_incremental 0.0.0",
|
||||
"rustc_lint 0.0.0",
|
||||
"rustc_metadata 0.0.0",
|
||||
"rustc_mir 0.0.0",
|
||||
"rustc_passes 0.0.0",
|
||||
"rustc_plugin 0.0.0",
|
||||
"rustc_privacy 0.0.0",
|
||||
"rustc_resolve 0.0.0",
|
||||
"rustc_traits 0.0.0",
|
||||
"rustc_typeck 0.0.0",
|
||||
"scoped-tls 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serialize 0.0.0",
|
||||
"smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"syntax 0.0.0",
|
||||
"syntax_ext 0.0.0",
|
||||
"syntax_pos 0.0.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc_lint"
|
||||
version = "0.0.0"
|
||||
|
@ -107,6 +107,8 @@ fn main() {
|
||||
// actually downloaded, so we just always pass the `--sysroot` option.
|
||||
cmd.arg("--sysroot").arg(&sysroot);
|
||||
|
||||
cmd.arg("-Zexternal-macro-backtrace");
|
||||
|
||||
// When we build Rust dylibs they're all intended for intermediate
|
||||
// usage, so make sure we pass the -Cprefer-dynamic flag instead of
|
||||
// linking all deps statically into the dylib.
|
||||
|
@ -456,6 +456,7 @@ define_dep_nodes!( <'tcx>
|
||||
[eval_always] CoherenceInherentImplOverlapCheck,
|
||||
[] CoherenceCheckTrait(DefId),
|
||||
[eval_always] PrivacyAccessLevels(CrateNum),
|
||||
[eval_always] Analysis(CrateNum),
|
||||
|
||||
// Represents the MIR for a fn; also used as the task node for
|
||||
// things read/modify that MIR.
|
||||
|
@ -499,6 +499,13 @@ impl Input {
|
||||
Input::Str { ref mut input, .. } => Some(input),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn source_name(&self) -> FileName {
|
||||
match *self {
|
||||
Input::File(ref ifile) => ifile.clone().into(),
|
||||
Input::Str { ref name, .. } => name.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Hash)]
|
||||
|
@ -899,14 +899,14 @@ impl Session {
|
||||
|
||||
/// Returns the number of query threads that should be used for this
|
||||
/// compilation
|
||||
pub fn threads_from_opts(opts: &config::Options) -> usize {
|
||||
opts.debugging_opts.threads.unwrap_or(::num_cpus::get())
|
||||
pub fn threads_from_count(query_threads: Option<usize>) -> usize {
|
||||
query_threads.unwrap_or(::num_cpus::get())
|
||||
}
|
||||
|
||||
/// Returns the number of query threads that should be used for this
|
||||
/// compilation
|
||||
pub fn threads(&self) -> usize {
|
||||
Self::threads_from_opts(&self.opts)
|
||||
Self::threads_from_count(self.opts.debugging_opts.threads)
|
||||
}
|
||||
|
||||
/// Returns the number of codegen units that should be used for this
|
||||
@ -1023,16 +1023,67 @@ pub fn build_session(
|
||||
local_crate_source_file,
|
||||
registry,
|
||||
Lrc::new(source_map::SourceMap::new(file_path_mapping)),
|
||||
None,
|
||||
DiagnosticOutput::Default,
|
||||
Default::default(),
|
||||
)
|
||||
}
|
||||
|
||||
fn default_emitter(
|
||||
sopts: &config::Options,
|
||||
registry: errors::registry::Registry,
|
||||
source_map: &Lrc<source_map::SourceMap>,
|
||||
emitter_dest: Option<Box<dyn Write + Send>>,
|
||||
) -> Box<dyn Emitter + sync::Send> {
|
||||
match (sopts.error_format, emitter_dest) {
|
||||
(config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
|
||||
EmitterWriter::stderr(
|
||||
color_config,
|
||||
Some(source_map.clone()),
|
||||
false,
|
||||
sopts.debugging_opts.teach,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
|
||||
EmitterWriter::new(dst, Some(source_map.clone()), false, false)
|
||||
.ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Json(pretty), None) => Box::new(
|
||||
JsonEmitter::stderr(
|
||||
Some(registry),
|
||||
source_map.clone(),
|
||||
pretty,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
|
||||
JsonEmitter::new(
|
||||
dst,
|
||||
Some(registry),
|
||||
source_map.clone(),
|
||||
pretty,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Short(color_config), None) => Box::new(
|
||||
EmitterWriter::stderr(color_config, Some(source_map.clone()), true, false),
|
||||
),
|
||||
(config::ErrorOutputType::Short(_), Some(dst)) => {
|
||||
Box::new(EmitterWriter::new(dst, Some(source_map.clone()), true, false))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub enum DiagnosticOutput {
|
||||
Default,
|
||||
Raw(Box<dyn Write + Send>),
|
||||
Emitter(Box<dyn Emitter + Send + sync::Send>)
|
||||
}
|
||||
|
||||
pub fn build_session_with_source_map(
|
||||
sopts: config::Options,
|
||||
local_crate_source_file: Option<PathBuf>,
|
||||
registry: errors::registry::Registry,
|
||||
source_map: Lrc<source_map::SourceMap>,
|
||||
emitter_dest: Option<Box<dyn Write + Send>>,
|
||||
diagnostics_output: DiagnosticOutput,
|
||||
lint_caps: FxHashMap<lint::LintId, lint::Level>,
|
||||
) -> Session {
|
||||
// FIXME: This is not general enough to make the warning lint completely override
|
||||
// normal diagnostic warnings, since the warning lint can also be denied and changed
|
||||
@ -1054,42 +1105,13 @@ pub fn build_session_with_source_map(
|
||||
|
||||
let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
|
||||
|
||||
let emitter: Box<dyn Emitter + sync::Send> =
|
||||
match (sopts.error_format, emitter_dest) {
|
||||
(config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
|
||||
EmitterWriter::stderr(
|
||||
color_config,
|
||||
Some(source_map.clone()),
|
||||
false,
|
||||
sopts.debugging_opts.teach,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
|
||||
EmitterWriter::new(dst, Some(source_map.clone()), false, false)
|
||||
.ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Json(pretty), None) => Box::new(
|
||||
JsonEmitter::stderr(
|
||||
Some(registry),
|
||||
source_map.clone(),
|
||||
pretty,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
|
||||
JsonEmitter::new(
|
||||
dst,
|
||||
Some(registry),
|
||||
source_map.clone(),
|
||||
pretty,
|
||||
).ui_testing(sopts.debugging_opts.ui_testing),
|
||||
),
|
||||
(config::ErrorOutputType::Short(color_config), None) => Box::new(
|
||||
EmitterWriter::stderr(color_config, Some(source_map.clone()), true, false),
|
||||
),
|
||||
(config::ErrorOutputType::Short(_), Some(dst)) => {
|
||||
Box::new(EmitterWriter::new(dst, Some(source_map.clone()), true, false))
|
||||
}
|
||||
};
|
||||
let emitter = match diagnostics_output {
|
||||
DiagnosticOutput::Default => default_emitter(&sopts, registry, &source_map, None),
|
||||
DiagnosticOutput::Raw(write) => {
|
||||
default_emitter(&sopts, registry, &source_map, Some(write))
|
||||
}
|
||||
DiagnosticOutput::Emitter(emitter) => emitter,
|
||||
};
|
||||
|
||||
let diagnostic_handler = errors::Handler::with_emitter_and_flags(
|
||||
emitter,
|
||||
@ -1103,7 +1125,7 @@ pub fn build_session_with_source_map(
|
||||
},
|
||||
);
|
||||
|
||||
build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map)
|
||||
build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map, lint_caps)
|
||||
}
|
||||
|
||||
pub fn build_session_(
|
||||
@ -1111,6 +1133,7 @@ pub fn build_session_(
|
||||
local_crate_source_file: Option<PathBuf>,
|
||||
span_diagnostic: errors::Handler,
|
||||
source_map: Lrc<source_map::SourceMap>,
|
||||
driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
|
||||
) -> Session {
|
||||
let host_triple = TargetTriple::from_triple(config::host_triple());
|
||||
let host = Target::search(&host_triple).unwrap_or_else(|e|
|
||||
@ -1235,7 +1258,7 @@ pub fn build_session_(
|
||||
},
|
||||
has_global_allocator: Once::new(),
|
||||
has_panic_handler: Once::new(),
|
||||
driver_lint_caps: Default::default(),
|
||||
driver_lint_caps,
|
||||
};
|
||||
|
||||
validate_commandline_args_with_session_available(&sess);
|
||||
|
@ -50,7 +50,7 @@ use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
|
||||
StableVec};
|
||||
use arena::{TypedArena, SyncDroplessArena};
|
||||
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
|
||||
use rustc_data_structures::sync::{self, Lrc, Lock, WorkerLocal};
|
||||
use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
|
||||
use std::any::Any;
|
||||
use std::borrow::Borrow;
|
||||
use std::cmp::Ordering;
|
||||
@ -1285,8 +1285,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
||||
|
||||
let gcx = arenas.global_ctxt.as_ref().unwrap();
|
||||
|
||||
sync::assert_send_val(&gcx);
|
||||
|
||||
let r = tls::enter_global(gcx, f);
|
||||
|
||||
gcx.queries.record_computed_queries(s);
|
||||
|
@ -611,6 +611,12 @@ impl<'tcx> QueryDescription<'tcx> for queries::extern_crate<'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> QueryDescription<'tcx> for queries::analysis<'tcx> {
|
||||
fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
|
||||
"running analysis passes on this crate".into()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> QueryDescription<'tcx> for queries::lint_levels<'tcx> {
|
||||
fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
|
||||
"computing the lint levels for items in this crate".into()
|
||||
|
@ -19,7 +19,7 @@ use crate::mir::interpret::{ConstEvalRawResult, ConstEvalResult};
|
||||
use crate::mir::mono::CodegenUnit;
|
||||
use crate::mir;
|
||||
use crate::mir::interpret::GlobalId;
|
||||
use crate::session::{CompileResult, CrateDisambiguator};
|
||||
use crate::session::CrateDisambiguator;
|
||||
use crate::session::config::{EntryFnType, OutputFilenames, OptLevel};
|
||||
use crate::traits::{self, Vtable};
|
||||
use crate::traits::query::{
|
||||
@ -99,6 +99,9 @@ pub use self::on_disk_cache::OnDiskCache;
|
||||
// as they will raise an fatal error on query cycles instead.
|
||||
define_queries! { <'tcx>
|
||||
Other {
|
||||
/// Run analysis passes on the crate
|
||||
[] fn analysis: Analysis(CrateNum) -> Result<(), ErrorReported>,
|
||||
|
||||
/// Records the type of every item.
|
||||
[] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
|
||||
|
||||
@ -290,7 +293,8 @@ define_queries! { <'tcx>
|
||||
},
|
||||
|
||||
TypeChecking {
|
||||
[] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult,
|
||||
[] fn typeck_item_bodies:
|
||||
typeck_item_bodies_dep_node(CrateNum) -> Result<(), ErrorReported>,
|
||||
|
||||
[] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
|
||||
},
|
||||
|
@ -1357,6 +1357,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
|
||||
DepKind::CrateHash => { force!(crate_hash, krate!()); }
|
||||
DepKind::OriginalCrateName => { force!(original_crate_name, krate!()); }
|
||||
DepKind::ExtraFileName => { force!(extra_filename, krate!()); }
|
||||
DepKind::Analysis => { force!(analysis, krate!()); }
|
||||
|
||||
DepKind::AllTraitImplementations => {
|
||||
force!(all_trait_implementations, krate!());
|
||||
|
@ -33,6 +33,7 @@ rustc_save_analysis = { path = "../librustc_save_analysis" }
|
||||
rustc_traits = { path = "../librustc_traits" }
|
||||
rustc_codegen_utils = { path = "../librustc_codegen_utils" }
|
||||
rustc_typeck = { path = "../librustc_typeck" }
|
||||
rustc_interface = { path = "../librustc_interface" }
|
||||
serialize = { path = "../libserialize" }
|
||||
syntax = { path = "../libsyntax" }
|
||||
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
|
||||
|
@ -2,42 +2,39 @@ use rustc::dep_graph::DepGraph;
|
||||
use rustc::hir;
|
||||
use rustc::hir::lowering::lower_crate;
|
||||
use rustc::hir::map as hir_map;
|
||||
use rustc::hir::def_id::LOCAL_CRATE;
|
||||
use rustc::lint;
|
||||
use rustc::middle::{self, reachable, resolve_lifetime, stability};
|
||||
use rustc::ty::{self, AllArenas, Resolutions, TyCtxt};
|
||||
use rustc::traits;
|
||||
use rustc::util::common::{install_panic_hook, time, ErrorReported};
|
||||
use rustc::util::profiling::ProfileCategory;
|
||||
use rustc::session::{CompileResult, CrateDisambiguator, Session};
|
||||
use rustc::session::{CompileResult, Session};
|
||||
use rustc::session::CompileIncomplete;
|
||||
use rustc::session::config::{self, Input, OutputFilenames, OutputType};
|
||||
use rustc::session::search_paths::PathKind;
|
||||
use rustc_allocator as allocator;
|
||||
use rustc_borrowck as borrowck;
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
use rustc_data_structures::fingerprint::Fingerprint;
|
||||
use rustc_data_structures::stable_hasher::StableHasher;
|
||||
use rustc_data_structures::sync::{self, Lock};
|
||||
use rustc_incremental;
|
||||
use rustc_metadata::creader::CrateLoader;
|
||||
use rustc_metadata::cstore::{self, CStore};
|
||||
use rustc_mir as mir;
|
||||
use rustc_passes::{self, ast_validation, hir_stats, loops, rvalue_promotion, layout_test};
|
||||
use rustc_passes::{self, ast_validation, hir_stats};
|
||||
use rustc_plugin as plugin;
|
||||
use rustc_plugin::registry::Registry;
|
||||
use rustc_privacy;
|
||||
use rustc_resolve::{Resolver, ResolverArenas};
|
||||
use rustc_traits;
|
||||
use rustc_typeck as typeck;
|
||||
use syntax::{self, ast, attr, diagnostics, visit};
|
||||
use syntax::{self, ast, diagnostics, visit};
|
||||
use syntax::early_buffered_lints::BufferedEarlyLint;
|
||||
use syntax::ext::base::ExtCtxt;
|
||||
use syntax::mut_visit::MutVisitor;
|
||||
use syntax::parse::{self, PResult};
|
||||
use syntax::util::node_count::NodeCounter;
|
||||
use syntax::util::lev_distance::find_best_match_for_name;
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax_pos::{FileName, hygiene};
|
||||
use syntax_pos::hygiene;
|
||||
use syntax_ext;
|
||||
|
||||
use serialize::json;
|
||||
@ -46,14 +43,11 @@ use std::any::Any;
|
||||
use std::env;
|
||||
use std::ffi::OsString;
|
||||
use std::fs;
|
||||
use std::io::{self, Write};
|
||||
use std::iter;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::mpsc;
|
||||
|
||||
use pretty::ReplaceBodyWithLoop;
|
||||
use proc_macro_decls;
|
||||
use profile;
|
||||
use rustc_interface::{util, profile, passes};
|
||||
use super::Compilation;
|
||||
|
||||
#[cfg(not(parallel_compiler))]
|
||||
@ -78,7 +72,7 @@ pub fn spawn_thread_pool<F: FnOnce(config::Options) -> R + sync::Send, R: sync::
|
||||
let gcx_ptr = &Lock::new(0);
|
||||
|
||||
let config = ThreadPoolBuilder::new()
|
||||
.num_threads(Session::threads_from_opts(&opts))
|
||||
.num_threads(Session::threads_from_count(opts.debugging_opts.threads))
|
||||
.deadlock_handler(|| unsafe { ty::query::handle_deadlock() })
|
||||
.stack_size(::STACK_SIZE);
|
||||
|
||||
@ -160,7 +154,7 @@ pub fn compile_input(
|
||||
(compile_state.krate.unwrap(), compile_state.registry)
|
||||
};
|
||||
|
||||
let outputs = build_output_filenames(input, outdir, output, &krate.attrs, sess);
|
||||
let outputs = util::build_output_filenames(input, outdir, output, &krate.attrs, sess);
|
||||
let crate_name =
|
||||
::rustc_codegen_utils::link::find_crate_name(Some(sess), &krate.attrs, input);
|
||||
install_panic_hook();
|
||||
@ -194,12 +188,17 @@ pub fn compile_input(
|
||||
)?
|
||||
};
|
||||
|
||||
let output_paths = generated_output_paths(sess, &outputs, output.is_some(), &crate_name);
|
||||
let output_paths = passes::generated_output_paths(
|
||||
sess,
|
||||
&outputs,
|
||||
output.is_some(),
|
||||
&crate_name
|
||||
);
|
||||
|
||||
// Ensure the source file isn't accidentally overwritten during compilation.
|
||||
if let Some(ref input_path) = *input_path {
|
||||
if sess.opts.will_create_output_file() {
|
||||
if output_contains_path(&output_paths, input_path) {
|
||||
if passes::output_contains_path(&output_paths, input_path) {
|
||||
sess.err(&format!(
|
||||
"the input file \"{}\" would be overwritten by the generated \
|
||||
executable",
|
||||
@ -207,7 +206,7 @@ pub fn compile_input(
|
||||
));
|
||||
return Err(CompileIncomplete::Stopped);
|
||||
}
|
||||
if let Some(dir_path) = output_conflicts_with_dir(&output_paths) {
|
||||
if let Some(dir_path) = passes::output_conflicts_with_dir(&output_paths) {
|
||||
sess.err(&format!(
|
||||
"the generated executable for the input file \"{}\" conflicts with the \
|
||||
existing directory \"{}\"",
|
||||
@ -219,7 +218,7 @@ pub fn compile_input(
|
||||
}
|
||||
}
|
||||
|
||||
write_out_deps(sess, &outputs, &output_paths);
|
||||
passes::write_out_deps(sess, &outputs, &output_paths);
|
||||
if sess.opts.output_types.contains_key(&OutputType::DepInfo)
|
||||
&& sess.opts.output_types.len() == 1
|
||||
{
|
||||
@ -333,7 +332,7 @@ pub fn compile_input(
|
||||
|
||||
Ok((outputs.clone(), ongoing_codegen, tcx.dep_graph.clone()))
|
||||
},
|
||||
)??
|
||||
)?
|
||||
};
|
||||
|
||||
if sess.opts.debugging_opts.print_type_sizes {
|
||||
@ -364,13 +363,6 @@ pub fn compile_input(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn source_name(input: &Input) -> FileName {
|
||||
match *input {
|
||||
Input::File(ref ifile) => ifile.clone().into(),
|
||||
Input::Str { ref name, .. } => name.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
/// CompileController is used to customize compilation, it allows compilation to
|
||||
/// be stopped and/or to call arbitrary code at various points in compilation.
|
||||
/// It also allows for various flags to be set to influence what information gets
|
||||
@ -806,10 +798,10 @@ where
|
||||
// these need to be set "early" so that expansion sees `quote` if enabled.
|
||||
sess.init_features(features);
|
||||
|
||||
let crate_types = collect_crate_types(sess, &krate.attrs);
|
||||
let crate_types = util::collect_crate_types(sess, &krate.attrs);
|
||||
sess.crate_types.set(crate_types);
|
||||
|
||||
let disambiguator = compute_crate_disambiguator(sess);
|
||||
let disambiguator = util::compute_crate_disambiguator(sess);
|
||||
sess.crate_disambiguator.set(disambiguator);
|
||||
rustc_incremental::prepare_session_directory(sess, &crate_name, disambiguator);
|
||||
|
||||
@ -1019,7 +1011,7 @@ where
|
||||
// If we're actually rustdoc then there's no need to actually compile
|
||||
// anything, so switch everything to just looping
|
||||
if sess.opts.actually_rustdoc {
|
||||
ReplaceBodyWithLoop::new(sess).visit_crate(&mut krate);
|
||||
util::ReplaceBodyWithLoop::new(sess).visit_crate(&mut krate);
|
||||
}
|
||||
|
||||
let (has_proc_macro_decls, has_global_allocator) = time(sess, "AST validation", || {
|
||||
@ -1145,7 +1137,7 @@ where
|
||||
}
|
||||
|
||||
pub fn default_provide(providers: &mut ty::query::Providers) {
|
||||
proc_macro_decls::provide(providers);
|
||||
rustc_interface::passes::provide(providers);
|
||||
plugin::build::provide(providers);
|
||||
hir::provide(providers);
|
||||
borrowck::provide(providers);
|
||||
@ -1186,7 +1178,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(
|
||||
name: &str,
|
||||
output_filenames: &OutputFilenames,
|
||||
f: F,
|
||||
) -> Result<R, CompileIncomplete>
|
||||
) -> R
|
||||
where
|
||||
F: for<'a> FnOnce(
|
||||
TyCtxt<'a, 'tcx, 'tcx>,
|
||||
@ -1227,114 +1219,9 @@ where
|
||||
// tcx available.
|
||||
time(sess, "dep graph tcx init", || rustc_incremental::dep_graph_tcx_init(tcx));
|
||||
|
||||
parallel!({
|
||||
time(sess, "looking for entry point", || {
|
||||
middle::entry::find_entry_point(tcx)
|
||||
});
|
||||
tcx.analysis(LOCAL_CRATE).ok();
|
||||
|
||||
time(sess, "looking for plugin registrar", || {
|
||||
plugin::build::find_plugin_registrar(tcx)
|
||||
});
|
||||
|
||||
time(sess, "looking for derive registrar", || {
|
||||
proc_macro_decls::find(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "loop checking", || loops::check_crate(tcx));
|
||||
}, {
|
||||
time(sess, "attribute checking", || {
|
||||
hir::check_attr::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "stability checking", || {
|
||||
stability::check_unstable_api_usage(tcx)
|
||||
});
|
||||
});
|
||||
|
||||
// passes are timed inside typeck
|
||||
match typeck::check_crate(tcx) {
|
||||
Ok(x) => x,
|
||||
Err(x) => {
|
||||
f(tcx, rx, Err(x));
|
||||
return Err(x);
|
||||
}
|
||||
}
|
||||
|
||||
time(sess, "misc checking", || {
|
||||
parallel!({
|
||||
time(sess, "rvalue promotion", || {
|
||||
rvalue_promotion::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "intrinsic checking", || {
|
||||
middle::intrinsicck::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "match checking", || mir::matchck_crate(tcx));
|
||||
}, {
|
||||
// this must run before MIR dump, because
|
||||
// "not all control paths return a value" is reported here.
|
||||
//
|
||||
// maybe move the check to a MIR pass?
|
||||
time(sess, "liveness checking", || {
|
||||
middle::liveness::check_crate(tcx)
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// Abort so we don't try to construct MIR with liveness errors.
|
||||
// We also won't want to continue with errors from rvalue promotion
|
||||
tcx.sess.abort_if_errors();
|
||||
|
||||
time(sess, "borrow checking", || {
|
||||
if tcx.use_ast_borrowck() {
|
||||
borrowck::check_crate(tcx);
|
||||
}
|
||||
});
|
||||
|
||||
time(sess,
|
||||
"MIR borrow checking",
|
||||
|| tcx.par_body_owners(|def_id| { tcx.ensure().mir_borrowck(def_id); }));
|
||||
|
||||
time(sess, "dumping chalk-like clauses", || {
|
||||
rustc_traits::lowering::dump_program_clauses(tcx);
|
||||
});
|
||||
|
||||
time(sess, "MIR effect checking", || {
|
||||
for def_id in tcx.body_owners() {
|
||||
mir::transform::check_unsafety::check_unsafety(tcx, def_id)
|
||||
}
|
||||
});
|
||||
|
||||
time(sess, "layout testing", || layout_test::test_layout(tcx));
|
||||
|
||||
// Avoid overwhelming user with errors if borrow checking failed.
|
||||
// I'm not sure how helpful this is, to be honest, but it avoids
|
||||
// a
|
||||
// lot of annoying errors in the compile-fail tests (basically,
|
||||
// lint warnings and so on -- kindck used to do this abort, but
|
||||
// kindck is gone now). -nmatsakis
|
||||
if sess.err_count() > 0 {
|
||||
return Ok(f(tcx, rx, sess.compile_status()));
|
||||
}
|
||||
|
||||
time(sess, "misc checking", || {
|
||||
parallel!({
|
||||
time(sess, "privacy checking", || {
|
||||
rustc_privacy::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "death checking", || middle::dead::check_crate(tcx));
|
||||
}, {
|
||||
time(sess, "unused lib feature checking", || {
|
||||
stability::check_unused_or_stable_features(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "lint checking", || lint::check_crate(tcx));
|
||||
});
|
||||
});
|
||||
|
||||
return Ok(f(tcx, rx, tcx.sess.compile_status()));
|
||||
f(tcx, rx, tcx.sess.compile_status())
|
||||
},
|
||||
)
|
||||
}
|
||||
@ -1359,328 +1246,3 @@ pub fn phase_4_codegen<'a, 'tcx>(
|
||||
|
||||
codegen
|
||||
}
|
||||
|
||||
fn escape_dep_filename(filename: &FileName) -> String {
|
||||
// Apparently clang and gcc *only* escape spaces:
|
||||
// http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
|
||||
filename.to_string().replace(" ", "\\ ")
|
||||
}
|
||||
|
||||
// Returns all the paths that correspond to generated files.
|
||||
fn generated_output_paths(
|
||||
sess: &Session,
|
||||
outputs: &OutputFilenames,
|
||||
exact_name: bool,
|
||||
crate_name: &str,
|
||||
) -> Vec<PathBuf> {
|
||||
let mut out_filenames = Vec::new();
|
||||
for output_type in sess.opts.output_types.keys() {
|
||||
let file = outputs.path(*output_type);
|
||||
match *output_type {
|
||||
// If the filename has been overridden using `-o`, it will not be modified
|
||||
// by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
|
||||
OutputType::Exe if !exact_name => for crate_type in sess.crate_types.borrow().iter() {
|
||||
let p = ::rustc_codegen_utils::link::filename_for_input(
|
||||
sess,
|
||||
*crate_type,
|
||||
crate_name,
|
||||
outputs,
|
||||
);
|
||||
out_filenames.push(p);
|
||||
},
|
||||
OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
|
||||
// Don't add the dep-info output when omitting it from dep-info targets
|
||||
}
|
||||
_ => {
|
||||
out_filenames.push(file);
|
||||
}
|
||||
}
|
||||
}
|
||||
out_filenames
|
||||
}
|
||||
|
||||
// Runs `f` on every output file path and returns the first non-None result, or None if `f`
|
||||
// returns None for every file path.
|
||||
fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
|
||||
where
|
||||
F: Fn(&PathBuf) -> Option<T>,
|
||||
{
|
||||
for output_path in output_paths {
|
||||
if let Some(result) = f(output_path) {
|
||||
return Some(result);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
|
||||
let input_path = input_path.canonicalize().ok();
|
||||
if input_path.is_none() {
|
||||
return false;
|
||||
}
|
||||
let check = |output_path: &PathBuf| {
|
||||
if output_path.canonicalize().ok() == input_path {
|
||||
Some(())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
check_output(output_paths, check).is_some()
|
||||
}
|
||||
|
||||
pub fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
|
||||
let check = |output_path: &PathBuf| {
|
||||
if output_path.is_dir() {
|
||||
Some(output_path.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
check_output(output_paths, check)
|
||||
}
|
||||
|
||||
fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &[PathBuf]) {
|
||||
// Write out dependency rules to the dep-info file if requested
|
||||
if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
|
||||
return;
|
||||
}
|
||||
let deps_filename = outputs.path(OutputType::DepInfo);
|
||||
|
||||
let result = (|| -> io::Result<()> {
|
||||
// Build a list of files used to compile the output and
|
||||
// write Makefile-compatible dependency rules
|
||||
let files: Vec<String> = sess.source_map()
|
||||
.files()
|
||||
.iter()
|
||||
.filter(|fmap| fmap.is_real_file())
|
||||
.filter(|fmap| !fmap.is_imported())
|
||||
.map(|fmap| escape_dep_filename(&fmap.name))
|
||||
.collect();
|
||||
let mut file = fs::File::create(&deps_filename)?;
|
||||
for path in out_filenames {
|
||||
writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
|
||||
}
|
||||
|
||||
// Emit a fake target for each input file to the compilation. This
|
||||
// prevents `make` from spitting out an error if a file is later
|
||||
// deleted. For more info see #28735
|
||||
for path in files {
|
||||
writeln!(file, "{}:", path)?;
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
if let Err(e) = result {
|
||||
sess.fatal(&format!(
|
||||
"error writing dependencies to `{}`: {}",
|
||||
deps_filename.display(),
|
||||
e
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
|
||||
// Unconditionally collect crate types from attributes to make them used
|
||||
let attr_types: Vec<config::CrateType> = attrs
|
||||
.iter()
|
||||
.filter_map(|a| {
|
||||
if a.check_name("crate_type") {
|
||||
match a.value_str() {
|
||||
Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib),
|
||||
Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib),
|
||||
Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib),
|
||||
Some(ref n) if *n == "lib" => Some(config::default_lib_output()),
|
||||
Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib),
|
||||
Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro),
|
||||
Some(ref n) if *n == "bin" => Some(config::CrateType::Executable),
|
||||
Some(ref n) => {
|
||||
let crate_types = vec![
|
||||
Symbol::intern("rlib"),
|
||||
Symbol::intern("dylib"),
|
||||
Symbol::intern("cdylib"),
|
||||
Symbol::intern("lib"),
|
||||
Symbol::intern("staticlib"),
|
||||
Symbol::intern("proc-macro"),
|
||||
Symbol::intern("bin")
|
||||
];
|
||||
|
||||
if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node {
|
||||
let span = spanned.span;
|
||||
let lev_candidate = find_best_match_for_name(
|
||||
crate_types.iter(),
|
||||
&n.as_str(),
|
||||
None
|
||||
);
|
||||
if let Some(candidate) = lev_candidate {
|
||||
session.buffer_lint_with_diagnostic(
|
||||
lint::builtin::UNKNOWN_CRATE_TYPES,
|
||||
ast::CRATE_NODE_ID,
|
||||
span,
|
||||
"invalid `crate_type` value",
|
||||
lint::builtin::BuiltinLintDiagnostics::
|
||||
UnknownCrateTypes(
|
||||
span,
|
||||
"did you mean".to_string(),
|
||||
format!("\"{}\"", candidate)
|
||||
)
|
||||
);
|
||||
} else {
|
||||
session.buffer_lint(
|
||||
lint::builtin::UNKNOWN_CRATE_TYPES,
|
||||
ast::CRATE_NODE_ID,
|
||||
span,
|
||||
"invalid `crate_type` value"
|
||||
);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
None => None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
// If we're generating a test executable, then ignore all other output
|
||||
// styles at all other locations
|
||||
if session.opts.test {
|
||||
return vec![config::CrateType::Executable];
|
||||
}
|
||||
|
||||
// Only check command line flags if present. If no types are specified by
|
||||
// command line, then reuse the empty `base` Vec to hold the types that
|
||||
// will be found in crate attributes.
|
||||
let mut base = session.opts.crate_types.clone();
|
||||
if base.is_empty() {
|
||||
base.extend(attr_types);
|
||||
if base.is_empty() {
|
||||
base.push(::rustc_codegen_utils::link::default_output_for_target(
|
||||
session,
|
||||
));
|
||||
} else {
|
||||
base.sort();
|
||||
base.dedup();
|
||||
}
|
||||
}
|
||||
|
||||
base.retain(|crate_type| {
|
||||
let res = !::rustc_codegen_utils::link::invalid_output_for_target(session, *crate_type);
|
||||
|
||||
if !res {
|
||||
session.warn(&format!(
|
||||
"dropping unsupported crate type `{}` for target `{}`",
|
||||
*crate_type, session.opts.target_triple
|
||||
));
|
||||
}
|
||||
|
||||
res
|
||||
});
|
||||
|
||||
base
|
||||
}
|
||||
|
||||
pub fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator {
|
||||
use std::hash::Hasher;
|
||||
|
||||
// The crate_disambiguator is a 128 bit hash. The disambiguator is fed
|
||||
// into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
|
||||
// debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
|
||||
// should still be safe enough to avoid collisions in practice.
|
||||
let mut hasher = StableHasher::<Fingerprint>::new();
|
||||
|
||||
let mut metadata = session.opts.cg.metadata.clone();
|
||||
// We don't want the crate_disambiguator to dependent on the order
|
||||
// -C metadata arguments, so sort them:
|
||||
metadata.sort();
|
||||
// Every distinct -C metadata value is only incorporated once:
|
||||
metadata.dedup();
|
||||
|
||||
hasher.write(b"metadata");
|
||||
for s in &metadata {
|
||||
// Also incorporate the length of a metadata string, so that we generate
|
||||
// different values for `-Cmetadata=ab -Cmetadata=c` and
|
||||
// `-Cmetadata=a -Cmetadata=bc`
|
||||
hasher.write_usize(s.len());
|
||||
hasher.write(s.as_bytes());
|
||||
}
|
||||
|
||||
// Also incorporate crate type, so that we don't get symbol conflicts when
|
||||
// linking against a library of the same name, if this is an executable.
|
||||
let is_exe = session
|
||||
.crate_types
|
||||
.borrow()
|
||||
.contains(&config::CrateType::Executable);
|
||||
hasher.write(if is_exe { b"exe" } else { b"lib" });
|
||||
|
||||
CrateDisambiguator::from(hasher.finish())
|
||||
}
|
||||
|
||||
pub fn build_output_filenames(
|
||||
input: &Input,
|
||||
odir: &Option<PathBuf>,
|
||||
ofile: &Option<PathBuf>,
|
||||
attrs: &[ast::Attribute],
|
||||
sess: &Session,
|
||||
) -> OutputFilenames {
|
||||
match *ofile {
|
||||
None => {
|
||||
// "-" as input file will cause the parser to read from stdin so we
|
||||
// have to make up a name
|
||||
// We want to toss everything after the final '.'
|
||||
let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
|
||||
|
||||
// If a crate name is present, we use it as the link name
|
||||
let stem = sess.opts
|
||||
.crate_name
|
||||
.clone()
|
||||
.or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
|
||||
.unwrap_or_else(|| input.filestem().to_owned());
|
||||
|
||||
OutputFilenames {
|
||||
out_directory: dirpath,
|
||||
out_filestem: stem,
|
||||
single_output_file: None,
|
||||
extra: sess.opts.cg.extra_filename.clone(),
|
||||
outputs: sess.opts.output_types.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
Some(ref out_file) => {
|
||||
let unnamed_output_types = sess.opts
|
||||
.output_types
|
||||
.values()
|
||||
.filter(|a| a.is_none())
|
||||
.count();
|
||||
let ofile = if unnamed_output_types > 1 {
|
||||
sess.warn(
|
||||
"due to multiple output types requested, the explicitly specified \
|
||||
output file name will be adapted for each output type",
|
||||
);
|
||||
None
|
||||
} else {
|
||||
Some(out_file.clone())
|
||||
};
|
||||
if *odir != None {
|
||||
sess.warn("ignoring --out-dir flag due to -o flag");
|
||||
}
|
||||
if !sess.opts.cg.extra_filename.is_empty() {
|
||||
sess.warn("ignoring -C extra-filename flag due to -o flag");
|
||||
}
|
||||
|
||||
OutputFilenames {
|
||||
out_directory: out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
|
||||
out_filestem: out_file
|
||||
.file_stem()
|
||||
.unwrap_or_default()
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_string(),
|
||||
single_output_file: ofile,
|
||||
extra: sess.opts.cg.extra_filename.clone(),
|
||||
outputs: sess.opts.output_types.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -27,7 +27,6 @@ extern crate rustc;
|
||||
extern crate rustc_allocator;
|
||||
extern crate rustc_target;
|
||||
extern crate rustc_borrowck;
|
||||
#[macro_use]
|
||||
extern crate rustc_data_structures;
|
||||
extern crate rustc_errors as errors;
|
||||
extern crate rustc_passes;
|
||||
@ -42,6 +41,7 @@ extern crate rustc_save_analysis;
|
||||
extern crate rustc_traits;
|
||||
extern crate rustc_codegen_utils;
|
||||
extern crate rustc_typeck;
|
||||
extern crate rustc_interface;
|
||||
extern crate scoped_tls;
|
||||
extern crate serialize;
|
||||
extern crate smallvec;
|
||||
@ -58,19 +58,18 @@ use rustc_save_analysis as save;
|
||||
use rustc_save_analysis::DumpHandler;
|
||||
use rustc_data_structures::sync::{self, Lrc, Ordering::SeqCst};
|
||||
use rustc_data_structures::OnDrop;
|
||||
use rustc::session::{self, config, Session, build_session, CompileResult};
|
||||
use rustc::session::{self, config, Session, build_session, CompileResult, DiagnosticOutput};
|
||||
use rustc::session::CompileIncomplete;
|
||||
use rustc::session::config::{Input, PrintRequest, ErrorOutputType};
|
||||
use rustc::session::config::nightly_options;
|
||||
use rustc::session::filesearch;
|
||||
use rustc::session::{early_error, early_warn};
|
||||
use rustc::lint::Lint;
|
||||
use rustc::lint;
|
||||
use rustc_metadata::locator;
|
||||
use rustc_metadata::cstore::CStore;
|
||||
use rustc_metadata::dynamic_lib::DynamicLibrary;
|
||||
use rustc::util::common::{time, ErrorReported};
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
use rustc_interface::util::{self, get_codegen_sysroot};
|
||||
|
||||
use serialize::json::ToJson;
|
||||
|
||||
@ -78,19 +77,15 @@ use std::any::Any;
|
||||
use std::borrow::Cow;
|
||||
use std::cmp::max;
|
||||
use std::default::Default;
|
||||
use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
|
||||
use std::env;
|
||||
use std::error::Error;
|
||||
use std::ffi::OsString;
|
||||
use std::fmt::{self, Display};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::mem;
|
||||
use std::panic;
|
||||
use std::path::{PathBuf, Path};
|
||||
use std::path::PathBuf;
|
||||
use std::process::{self, Command, Stdio};
|
||||
use std::str;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Once, ONCE_INIT};
|
||||
use std::thread;
|
||||
|
||||
use syntax::ast;
|
||||
@ -102,34 +97,8 @@ use syntax_pos::{DUMMY_SP, MultiSpan, FileName};
|
||||
#[cfg(test)]
|
||||
mod test;
|
||||
|
||||
pub mod profile;
|
||||
pub mod driver;
|
||||
pub mod pretty;
|
||||
mod proc_macro_decls;
|
||||
|
||||
pub mod target_features {
|
||||
use syntax::ast;
|
||||
use syntax::symbol::Symbol;
|
||||
use rustc::session::Session;
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
|
||||
/// Adds `target_feature = "..."` cfgs for a variety of platform
|
||||
/// specific features (SSE, NEON etc.).
|
||||
///
|
||||
/// This is performed by checking whether a whitelisted set of
|
||||
/// features is available on the target machine, by querying LLVM.
|
||||
pub fn add_configuration(cfg: &mut ast::CrateConfig,
|
||||
sess: &Session,
|
||||
codegen_backend: &dyn CodegenBackend) {
|
||||
let tf = Symbol::intern("target_feature");
|
||||
|
||||
cfg.extend(codegen_backend.target_features(sess).into_iter().map(|feat| (tf, Some(feat))));
|
||||
|
||||
if sess.crt_static_feature() {
|
||||
cfg.insert((tf, Some(Symbol::intern("crt-static"))));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Exit status code used for successful compilation and help output.
|
||||
pub const EXIT_SUCCESS: isize = 0;
|
||||
@ -196,235 +165,6 @@ pub fn run<F>(run_compiler: F) -> isize
|
||||
}
|
||||
}
|
||||
|
||||
fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
|
||||
let lib = DynamicLibrary::open(Some(path)).unwrap_or_else(|err| {
|
||||
let err = format!("couldn't load codegen backend {:?}: {:?}", path, err);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
unsafe {
|
||||
match lib.symbol("__rustc_codegen_backend") {
|
||||
Ok(f) => {
|
||||
mem::forget(lib);
|
||||
mem::transmute::<*mut u8, _>(f)
|
||||
}
|
||||
Err(e) => {
|
||||
let err = format!("couldn't load codegen backend as it \
|
||||
doesn't export the `__rustc_codegen_backend` \
|
||||
symbol: {:?}", e);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
|
||||
static INIT: Once = ONCE_INIT;
|
||||
|
||||
#[allow(deprecated)]
|
||||
#[no_debug]
|
||||
static mut LOAD: fn() -> Box<dyn CodegenBackend> = || unreachable!();
|
||||
|
||||
INIT.call_once(|| {
|
||||
let codegen_name = sess.opts.debugging_opts.codegen_backend.as_ref()
|
||||
.unwrap_or(&sess.target.target.options.codegen_backend);
|
||||
let backend = match &codegen_name[..] {
|
||||
"metadata_only" => {
|
||||
rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
|
||||
}
|
||||
filename if filename.contains(".") => {
|
||||
load_backend_from_dylib(filename.as_ref())
|
||||
}
|
||||
codegen_name => get_codegen_sysroot(codegen_name),
|
||||
};
|
||||
|
||||
unsafe {
|
||||
LOAD = backend;
|
||||
}
|
||||
});
|
||||
let backend = unsafe { LOAD() };
|
||||
backend.init(sess);
|
||||
backend
|
||||
}
|
||||
|
||||
fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend> {
|
||||
// For now we only allow this function to be called once as it'll dlopen a
|
||||
// few things, which seems to work best if we only do that once. In
|
||||
// general this assertion never trips due to the once guard in `get_codegen_backend`,
|
||||
// but there's a few manual calls to this function in this file we protect
|
||||
// against.
|
||||
static LOADED: AtomicBool = AtomicBool::new(false);
|
||||
assert!(!LOADED.fetch_or(true, Ordering::SeqCst),
|
||||
"cannot load the default codegen backend twice");
|
||||
|
||||
// When we're compiling this library with `--test` it'll run as a binary but
|
||||
// not actually exercise much functionality. As a result most of the logic
|
||||
// here is defunkt (it assumes we're a dynamic library in a sysroot) so
|
||||
// let's just return a dummy creation function which won't be used in
|
||||
// general anyway.
|
||||
if cfg!(test) {
|
||||
return rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
|
||||
}
|
||||
|
||||
let target = session::config::host_triple();
|
||||
let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
|
||||
let path = current_dll_path()
|
||||
.and_then(|s| s.canonicalize().ok());
|
||||
if let Some(dll) = path {
|
||||
// use `parent` twice to chop off the file name and then also the
|
||||
// directory containing the dll which should be either `lib` or `bin`.
|
||||
if let Some(path) = dll.parent().and_then(|p| p.parent()) {
|
||||
// The original `path` pointed at the `rustc_driver` crate's dll.
|
||||
// Now that dll should only be in one of two locations. The first is
|
||||
// in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
|
||||
// other is the target's libdir, for example
|
||||
// `$sysroot/lib/rustlib/$target/lib/*.dll`.
|
||||
//
|
||||
// We don't know which, so let's assume that if our `path` above
|
||||
// ends in `$target` we *could* be in the target libdir, and always
|
||||
// assume that we may be in the main libdir.
|
||||
sysroot_candidates.push(path.to_owned());
|
||||
|
||||
if path.ends_with(target) {
|
||||
sysroot_candidates.extend(path.parent() // chop off `$target`
|
||||
.and_then(|p| p.parent()) // chop off `rustlib`
|
||||
.and_then(|p| p.parent()) // chop off `lib`
|
||||
.map(|s| s.to_owned()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let sysroot = sysroot_candidates.iter()
|
||||
.map(|sysroot| {
|
||||
let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
|
||||
sysroot.join(libdir).with_file_name(
|
||||
option_env!("CFG_CODEGEN_BACKENDS_DIR").unwrap_or("codegen-backends"))
|
||||
})
|
||||
.filter(|f| {
|
||||
info!("codegen backend candidate: {}", f.display());
|
||||
f.exists()
|
||||
})
|
||||
.next();
|
||||
let sysroot = sysroot.unwrap_or_else(|| {
|
||||
let candidates = sysroot_candidates.iter()
|
||||
.map(|p| p.display().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n* ");
|
||||
let err = format!("failed to find a `codegen-backends` folder \
|
||||
in the sysroot candidates:\n* {}", candidates);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
info!("probing {} for a codegen backend", sysroot.display());
|
||||
|
||||
let d = sysroot.read_dir().unwrap_or_else(|e| {
|
||||
let err = format!("failed to load default codegen backend, couldn't \
|
||||
read `{}`: {}", sysroot.display(), e);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
|
||||
let mut file: Option<PathBuf> = None;
|
||||
|
||||
let expected_name = format!("rustc_codegen_llvm-{}", backend_name);
|
||||
for entry in d.filter_map(|e| e.ok()) {
|
||||
let path = entry.path();
|
||||
let filename = match path.file_name().and_then(|s| s.to_str()) {
|
||||
Some(s) => s,
|
||||
None => continue,
|
||||
};
|
||||
if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
|
||||
continue
|
||||
}
|
||||
let name = &filename[DLL_PREFIX.len() .. filename.len() - DLL_SUFFIX.len()];
|
||||
if name != expected_name {
|
||||
continue
|
||||
}
|
||||
if let Some(ref prev) = file {
|
||||
let err = format!("duplicate codegen backends found\n\
|
||||
first: {}\n\
|
||||
second: {}\n\
|
||||
", prev.display(), path.display());
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
file = Some(path.clone());
|
||||
}
|
||||
|
||||
match file {
|
||||
Some(ref s) => return load_backend_from_dylib(s),
|
||||
None => {
|
||||
let err = format!("failed to load default codegen backend for `{}`, \
|
||||
no appropriate codegen dylib found in `{}`",
|
||||
backend_name, sysroot.display());
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn current_dll_path() -> Option<PathBuf> {
|
||||
use std::ffi::{OsStr, CStr};
|
||||
use std::os::unix::prelude::*;
|
||||
|
||||
unsafe {
|
||||
let addr = current_dll_path as usize as *mut _;
|
||||
let mut info = mem::zeroed();
|
||||
if libc::dladdr(addr, &mut info) == 0 {
|
||||
info!("dladdr failed");
|
||||
return None
|
||||
}
|
||||
if info.dli_fname.is_null() {
|
||||
info!("dladdr returned null pointer");
|
||||
return None
|
||||
}
|
||||
let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
|
||||
let os = OsStr::from_bytes(bytes);
|
||||
Some(PathBuf::from(os))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn current_dll_path() -> Option<PathBuf> {
|
||||
use std::ffi::OsString;
|
||||
use std::os::windows::prelude::*;
|
||||
|
||||
extern "system" {
|
||||
fn GetModuleHandleExW(dwFlags: u32,
|
||||
lpModuleName: usize,
|
||||
phModule: *mut usize) -> i32;
|
||||
fn GetModuleFileNameW(hModule: usize,
|
||||
lpFilename: *mut u16,
|
||||
nSize: u32) -> u32;
|
||||
}
|
||||
|
||||
const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
|
||||
|
||||
unsafe {
|
||||
let mut module = 0;
|
||||
let r = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
|
||||
current_dll_path as usize,
|
||||
&mut module);
|
||||
if r == 0 {
|
||||
info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
let mut space = Vec::with_capacity(1024);
|
||||
let r = GetModuleFileNameW(module,
|
||||
space.as_mut_ptr(),
|
||||
space.capacity() as u32);
|
||||
if r == 0 {
|
||||
info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
let r = r as usize;
|
||||
if r >= space.capacity() {
|
||||
info!("our buffer was too small? {}",
|
||||
io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
space.set_len(r);
|
||||
let os = OsString::from_wide(&space);
|
||||
Some(PathBuf::from(os))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Parse args and run the compiler. This is the primary entry point for rustc.
|
||||
// See comments on CompilerCalls below for details about the callbacks argument.
|
||||
// The FileLoader provides a way to load files from sources other than the file system.
|
||||
@ -485,7 +225,12 @@ fn run_compiler_with_pool<'a>(
|
||||
let loader = file_loader.unwrap_or(box RealFileLoader);
|
||||
let source_map = Lrc::new(SourceMap::with_file_loader(loader, sopts.file_path_mapping()));
|
||||
let mut sess = session::build_session_with_source_map(
|
||||
sopts, input_file_path.clone(), descriptions, source_map, emitter_dest,
|
||||
sopts,
|
||||
input_file_path.clone(),
|
||||
descriptions,
|
||||
source_map,
|
||||
emitter_dest.map(|e| DiagnosticOutput::Raw(e)).unwrap_or(DiagnosticOutput::Default),
|
||||
Default::default(),
|
||||
);
|
||||
|
||||
if let Some(err) = input_err {
|
||||
@ -495,12 +240,12 @@ fn run_compiler_with_pool<'a>(
|
||||
return (Err(CompileIncomplete::Stopped), Some(sess));
|
||||
}
|
||||
|
||||
let codegen_backend = get_codegen_backend(&sess);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
|
||||
let mut cfg = config::build_configuration(&sess, cfg);
|
||||
target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
util::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
sess.parse_sess.config = cfg;
|
||||
|
||||
let result = {
|
||||
@ -710,8 +455,8 @@ fn stdout_isatty() -> bool {
|
||||
}
|
||||
|
||||
fn handle_explain(code: &str,
|
||||
descriptions: &errors::registry::Registry,
|
||||
output: ErrorOutputType) {
|
||||
let descriptions = rustc_interface::util::diagnostics_registry();
|
||||
let normalised = if code.starts_with("E") {
|
||||
code.to_string()
|
||||
} else {
|
||||
@ -788,11 +533,11 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
|
||||
matches: &getopts::Matches,
|
||||
_: &config::Options,
|
||||
_: &ast::CrateConfig,
|
||||
descriptions: &errors::registry::Registry,
|
||||
_: &errors::registry::Registry,
|
||||
output: ErrorOutputType)
|
||||
-> Compilation {
|
||||
if let Some(ref code) = matches.opt_str("explain") {
|
||||
handle_explain(code, descriptions, output);
|
||||
handle_explain(code, output);
|
||||
return Compilation::Stop;
|
||||
}
|
||||
|
||||
@ -820,8 +565,8 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
|
||||
}
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
let mut cfg = config::build_configuration(&sess, cfg.clone());
|
||||
let codegen_backend = get_codegen_backend(&sess);
|
||||
target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
util::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
sess.parse_sess.config = cfg;
|
||||
let should_stop = RustcDefaultCalls::print_crate_info(
|
||||
&*codegen_backend,
|
||||
@ -1024,13 +769,19 @@ impl RustcDefaultCalls {
|
||||
let input = input.unwrap_or_else(||
|
||||
early_error(ErrorOutputType::default(), "no input file provided"));
|
||||
let attrs = attrs.as_ref().unwrap();
|
||||
let t_outputs = driver::build_output_filenames(input, odir, ofile, attrs, sess);
|
||||
let t_outputs = rustc_interface::util::build_output_filenames(
|
||||
input,
|
||||
odir,
|
||||
ofile,
|
||||
attrs,
|
||||
sess
|
||||
);
|
||||
let id = rustc_codegen_utils::link::find_crate_name(Some(sess), attrs, input);
|
||||
if *req == PrintRequest::CrateName {
|
||||
println!("{}", id);
|
||||
continue;
|
||||
}
|
||||
let crate_types = driver::collect_crate_types(sess, attrs);
|
||||
let crate_types = rustc_interface::util::collect_crate_types(sess, attrs);
|
||||
for &style in &crate_types {
|
||||
let fname = rustc_codegen_utils::link::filename_for_input(
|
||||
sess,
|
||||
|
@ -9,36 +9,33 @@ use rustc::hir::print as pprust_hir;
|
||||
use rustc::session::Session;
|
||||
use rustc::session::config::{Input, OutputFilenames};
|
||||
use rustc::ty::{self, TyCtxt, Resolutions, AllArenas};
|
||||
use rustc_interface::util;
|
||||
use rustc_borrowck as borrowck;
|
||||
use rustc_borrowck::graphviz as borrowck_dot;
|
||||
use rustc_data_structures::thin_vec::ThinVec;
|
||||
use rustc_metadata::cstore::CStore;
|
||||
use rustc_mir::util::{write_mir_pretty, write_mir_graphviz};
|
||||
|
||||
use syntax::ast::{self, BlockCheckMode};
|
||||
use syntax::mut_visit::{*, MutVisitor, visit_clobber};
|
||||
use syntax::ast;
|
||||
use syntax::mut_visit::MutVisitor;
|
||||
use syntax::print::{pprust};
|
||||
use syntax::print::pprust::PrintState;
|
||||
use syntax::ptr::P;
|
||||
use syntax_pos::{self, FileName};
|
||||
use syntax_pos::FileName;
|
||||
|
||||
use graphviz as dot;
|
||||
use smallvec::SmallVec;
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::fs::File;
|
||||
use std::io::{self, Write};
|
||||
use std::ops::DerefMut;
|
||||
use std::option;
|
||||
use std::path::Path;
|
||||
use std::str::FromStr;
|
||||
use std::mem;
|
||||
|
||||
pub use self::UserIdentifiedItem::*;
|
||||
pub use self::PpSourceMode::*;
|
||||
pub use self::PpMode::*;
|
||||
use self::NodesMatchingUII::*;
|
||||
use {abort_on_err, driver};
|
||||
use abort_on_err;
|
||||
use driver;
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
pub enum PpSourceMode {
|
||||
@ -217,18 +214,19 @@ impl PpSourceMode {
|
||||
}
|
||||
PpmTyped => {
|
||||
let control = &driver::CompileController::basic();
|
||||
let codegen_backend = ::get_codegen_backend(sess);
|
||||
let codegen_backend = util::get_codegen_backend(sess);
|
||||
let mut arenas = AllArenas::new();
|
||||
abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
sess,
|
||||
cstore,
|
||||
hir_map.clone(),
|
||||
resolutions.clone(),
|
||||
&mut arenas,
|
||||
id,
|
||||
output_filenames,
|
||||
|tcx, _, _| {
|
||||
driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
sess,
|
||||
cstore,
|
||||
hir_map.clone(),
|
||||
resolutions.clone(),
|
||||
&mut arenas,
|
||||
id,
|
||||
output_filenames,
|
||||
|tcx, _, result| {
|
||||
abort_on_err(result, tcx.sess);
|
||||
let empty_tables = ty::TypeckTables::empty(None);
|
||||
let annotation = TypedAnnotation {
|
||||
tcx,
|
||||
@ -237,8 +235,7 @@ impl PpSourceMode {
|
||||
tcx.dep_graph.with_ignore(|| {
|
||||
f(&annotation, hir_map.forest.krate())
|
||||
})
|
||||
}),
|
||||
sess)
|
||||
})
|
||||
}
|
||||
_ => panic!("Should use call_with_pp_support"),
|
||||
}
|
||||
@ -627,204 +624,6 @@ impl UserIdentifiedItem {
|
||||
}
|
||||
}
|
||||
|
||||
// Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
|
||||
//
|
||||
// FIXME: Currently the `everybody_loops` transformation is not applied to:
|
||||
// * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
|
||||
// waiting for miri to fix that.
|
||||
// * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
|
||||
// Solving this may require `!` to implement every trait, which relies on the an even more
|
||||
// ambitious form of the closed RFC #1637. See also [#34511].
|
||||
//
|
||||
// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
|
||||
pub struct ReplaceBodyWithLoop<'a> {
|
||||
within_static_or_const: bool,
|
||||
nested_blocks: Option<Vec<ast::Block>>,
|
||||
sess: &'a Session,
|
||||
}
|
||||
|
||||
impl<'a> ReplaceBodyWithLoop<'a> {
|
||||
pub fn new(sess: &'a Session) -> ReplaceBodyWithLoop<'a> {
|
||||
ReplaceBodyWithLoop {
|
||||
within_static_or_const: false,
|
||||
nested_blocks: None,
|
||||
sess
|
||||
}
|
||||
}
|
||||
|
||||
fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
|
||||
let old_const = mem::replace(&mut self.within_static_or_const, is_const);
|
||||
let old_blocks = self.nested_blocks.take();
|
||||
let ret = action(self);
|
||||
self.within_static_or_const = old_const;
|
||||
self.nested_blocks = old_blocks;
|
||||
ret
|
||||
}
|
||||
|
||||
fn should_ignore_fn(ret_ty: &ast::FnDecl) -> bool {
|
||||
if let ast::FunctionRetTy::Ty(ref ty) = ret_ty.output {
|
||||
fn involves_impl_trait(ty: &ast::Ty) -> bool {
|
||||
match ty.node {
|
||||
ast::TyKind::ImplTrait(..) => true,
|
||||
ast::TyKind::Slice(ref subty) |
|
||||
ast::TyKind::Array(ref subty, _) |
|
||||
ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) |
|
||||
ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) |
|
||||
ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
|
||||
ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
|
||||
ast::TyKind::Path(_, ref path) => path.segments.iter().any(|seg| {
|
||||
match seg.args.as_ref().map(|generic_arg| &**generic_arg) {
|
||||
None => false,
|
||||
Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
|
||||
let types = data.args.iter().filter_map(|arg| match arg {
|
||||
ast::GenericArg::Type(ty) => Some(ty),
|
||||
_ => None,
|
||||
});
|
||||
any_involves_impl_trait(types.into_iter()) ||
|
||||
any_involves_impl_trait(data.bindings.iter().map(|b| &b.ty))
|
||||
},
|
||||
Some(&ast::GenericArgs::Parenthesized(ref data)) => {
|
||||
any_involves_impl_trait(data.inputs.iter()) ||
|
||||
any_involves_impl_trait(data.output.iter())
|
||||
}
|
||||
}
|
||||
}),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
|
||||
it.any(|subty| involves_impl_trait(subty))
|
||||
}
|
||||
|
||||
involves_impl_trait(ty)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> MutVisitor for ReplaceBodyWithLoop<'a> {
|
||||
fn visit_item_kind(&mut self, i: &mut ast::ItemKind) {
|
||||
let is_const = match i {
|
||||
ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
|
||||
ast::ItemKind::Fn(ref decl, ref header, _, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_visit_item_kind(i, s))
|
||||
}
|
||||
|
||||
fn flat_map_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
|
||||
let is_const = match i.node {
|
||||
ast::TraitItemKind::Const(..) => true,
|
||||
ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_flat_map_trait_item(i, s))
|
||||
}
|
||||
|
||||
fn flat_map_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
|
||||
let is_const = match i.node {
|
||||
ast::ImplItemKind::Const(..) => true,
|
||||
ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_flat_map_impl_item(i, s))
|
||||
}
|
||||
|
||||
fn visit_anon_const(&mut self, c: &mut ast::AnonConst) {
|
||||
self.run(true, |s| noop_visit_anon_const(c, s))
|
||||
}
|
||||
|
||||
fn visit_block(&mut self, b: &mut P<ast::Block>) {
|
||||
fn stmt_to_block(rules: ast::BlockCheckMode,
|
||||
s: Option<ast::Stmt>,
|
||||
sess: &Session) -> ast::Block {
|
||||
ast::Block {
|
||||
stmts: s.into_iter().collect(),
|
||||
rules,
|
||||
id: sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
}
|
||||
}
|
||||
|
||||
fn block_to_stmt(b: ast::Block, sess: &Session) -> ast::Stmt {
|
||||
let expr = P(ast::Expr {
|
||||
id: sess.next_node_id(),
|
||||
node: ast::ExprKind::Block(P(b), None),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
attrs: ThinVec::new(),
|
||||
});
|
||||
|
||||
ast::Stmt {
|
||||
id: sess.next_node_id(),
|
||||
node: ast::StmtKind::Expr(expr),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
}
|
||||
}
|
||||
|
||||
let empty_block = stmt_to_block(BlockCheckMode::Default, None, self.sess);
|
||||
let loop_expr = P(ast::Expr {
|
||||
node: ast::ExprKind::Loop(P(empty_block), None),
|
||||
id: self.sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
attrs: ThinVec::new(),
|
||||
});
|
||||
|
||||
let loop_stmt = ast::Stmt {
|
||||
id: self.sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
node: ast::StmtKind::Expr(loop_expr),
|
||||
};
|
||||
|
||||
if self.within_static_or_const {
|
||||
noop_visit_block(b, self)
|
||||
} else {
|
||||
visit_clobber(b.deref_mut(), |b| {
|
||||
let mut stmts = vec![];
|
||||
for s in b.stmts {
|
||||
let old_blocks = self.nested_blocks.replace(vec![]);
|
||||
|
||||
stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item()));
|
||||
|
||||
// we put a Some in there earlier with that replace(), so this is valid
|
||||
let new_blocks = self.nested_blocks.take().unwrap();
|
||||
self.nested_blocks = old_blocks;
|
||||
stmts.extend(new_blocks.into_iter().map(|b| block_to_stmt(b, &self.sess)));
|
||||
}
|
||||
|
||||
let mut new_block = ast::Block {
|
||||
stmts,
|
||||
..b
|
||||
};
|
||||
|
||||
if let Some(old_blocks) = self.nested_blocks.as_mut() {
|
||||
//push our fresh block onto the cache and yield an empty block with `loop {}`
|
||||
if !new_block.stmts.is_empty() {
|
||||
old_blocks.push(new_block);
|
||||
}
|
||||
|
||||
stmt_to_block(b.rules, Some(loop_stmt), self.sess)
|
||||
} else {
|
||||
//push `loop {}` onto the end of our fresh block and yield that
|
||||
new_block.stmts.push(loop_stmt);
|
||||
|
||||
new_block
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// in general the pretty printer processes unexpanded code, so
|
||||
// we override the default `visit_mac` method which panics.
|
||||
fn visit_mac(&mut self, mac: &mut ast::Mac) {
|
||||
noop_visit_mac(mac, self)
|
||||
}
|
||||
}
|
||||
|
||||
fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec<borrowck_dot::Variant>,
|
||||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
code: blocks::Code<'tcx>,
|
||||
@ -892,12 +691,12 @@ fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec<borrowck_dot::Variant>,
|
||||
|
||||
pub fn visit_crate(sess: &Session, krate: &mut ast::Crate, ppm: PpMode) {
|
||||
if let PpmSource(PpmEveryBodyLoops) = ppm {
|
||||
ReplaceBodyWithLoop::new(sess).visit_crate(krate);
|
||||
util::ReplaceBodyWithLoop::new(sess).visit_crate(krate);
|
||||
}
|
||||
}
|
||||
|
||||
fn get_source(input: &Input, sess: &Session) -> (Vec<u8>, FileName) {
|
||||
let src_name = driver::source_name(input);
|
||||
let src_name = input.source_name();
|
||||
let src = sess.source_map()
|
||||
.get_source_file(&src_name)
|
||||
.unwrap()
|
||||
@ -1117,18 +916,19 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session,
|
||||
let mut out = Vec::new();
|
||||
|
||||
let control = &driver::CompileController::basic();
|
||||
let codegen_backend = ::get_codegen_backend(sess);
|
||||
let codegen_backend = util::get_codegen_backend(sess);
|
||||
let mut arenas = AllArenas::new();
|
||||
abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
sess,
|
||||
cstore,
|
||||
hir_map.clone(),
|
||||
resolutions.clone(),
|
||||
&mut arenas,
|
||||
crate_name,
|
||||
output_filenames,
|
||||
|tcx, _, _| {
|
||||
driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
sess,
|
||||
cstore,
|
||||
hir_map.clone(),
|
||||
resolutions.clone(),
|
||||
&mut arenas,
|
||||
crate_name,
|
||||
output_filenames,
|
||||
|tcx, _, result| {
|
||||
abort_on_err(result, tcx.sess);
|
||||
match ppm {
|
||||
PpmMir | PpmMirCFG => {
|
||||
if let Some(nodeid) = nodeid {
|
||||
@ -1174,9 +974,7 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session,
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}),
|
||||
sess)
|
||||
.unwrap();
|
||||
}).unwrap();
|
||||
|
||||
write_output(out, ofile);
|
||||
}
|
||||
|
@ -16,6 +16,7 @@ use rustc::ty::query::OnDiskCache;
|
||||
use rustc::ty::subst::Subst;
|
||||
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
|
||||
use rustc_data_structures::sync::{self, Lrc};
|
||||
use rustc_interface::util;
|
||||
use rustc_lint;
|
||||
use rustc_metadata::cstore::CStore;
|
||||
use rustc_target::spec::abi::Abi;
|
||||
@ -91,6 +92,13 @@ where
|
||||
options.debugging_opts.verbose = true;
|
||||
options.unstable_features = UnstableFeatures::Allow;
|
||||
|
||||
// When we're compiling this library with `--test` it'll run as a binary but
|
||||
// not actually exercise much functionality.
|
||||
// As a result most of the logic loading the codegen backend is defunkt
|
||||
// (it assumes we're a dynamic library in a sysroot)
|
||||
// so let's just use the metadata only backend which doesn't need to load any libraries.
|
||||
options.debugging_opts.codegen_backend = Some("metadata_only".to_owned());
|
||||
|
||||
driver::spawn_thread_pool(options, |options| {
|
||||
test_env_with_pool(options, source_string, args, body)
|
||||
})
|
||||
@ -111,8 +119,9 @@ fn test_env_with_pool<F>(
|
||||
None,
|
||||
diagnostic_handler,
|
||||
Lrc::new(SourceMap::new(FilePathMapping::empty())),
|
||||
Default::default(),
|
||||
);
|
||||
let cstore = CStore::new(::get_codegen_backend(&sess).metadata_loader());
|
||||
let cstore = CStore::new(util::get_codegen_backend(&sess).metadata_loader());
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
let input = config::Input::Str {
|
||||
name: FileName::anon_source_code(&source_string),
|
||||
|
35
src/librustc_interface/Cargo.toml
Normal file
35
src/librustc_interface/Cargo.toml
Normal file
@ -0,0 +1,35 @@
|
||||
[package]
|
||||
authors = ["The Rust Project Developers"]
|
||||
name = "rustc_interface"
|
||||
version = "0.0.0"
|
||||
|
||||
[lib]
|
||||
name = "rustc_interface"
|
||||
path = "lib.rs"
|
||||
crate-type = ["dylib"]
|
||||
|
||||
[dependencies]
|
||||
log = "0.4"
|
||||
rustc-rayon = "0.1.1"
|
||||
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
|
||||
scoped-tls = { version = "0.1.1", features = ["nightly"] }
|
||||
syntax = { path = "../libsyntax" }
|
||||
syntax_ext = { path = "../libsyntax_ext" }
|
||||
syntax_pos = { path = "../libsyntax_pos" }
|
||||
serialize = { path = "../libserialize" }
|
||||
rustc = { path = "../librustc" }
|
||||
rustc_allocator = { path = "../librustc_allocator" }
|
||||
rustc_borrowck = { path = "../librustc_borrowck" }
|
||||
rustc_incremental = { path = "../librustc_incremental" }
|
||||
rustc_traits = { path = "../librustc_traits" }
|
||||
rustc_data_structures = { path = "../librustc_data_structures" }
|
||||
rustc_codegen_utils = { path = "../librustc_codegen_utils" }
|
||||
rustc_metadata = { path = "../librustc_metadata" }
|
||||
rustc_mir = { path = "../librustc_mir" }
|
||||
rustc_passes = { path = "../librustc_passes" }
|
||||
rustc_typeck = { path = "../librustc_typeck" }
|
||||
rustc_lint = { path = "../librustc_lint" }
|
||||
rustc_errors = { path = "../librustc_errors" }
|
||||
rustc_plugin = { path = "../librustc_plugin" }
|
||||
rustc_privacy = { path = "../librustc_privacy" }
|
||||
rustc_resolve = { path = "../librustc_resolve" }
|
43
src/librustc_interface/lib.rs
Normal file
43
src/librustc_interface/lib.rs
Normal file
@ -0,0 +1,43 @@
|
||||
#![feature(box_syntax)]
|
||||
#![feature(set_stdio)]
|
||||
#![feature(nll)]
|
||||
#![feature(arbitrary_self_types)]
|
||||
#![feature(generator_trait)]
|
||||
#![cfg_attr(unix, feature(libc))]
|
||||
|
||||
#![allow(unused_imports)]
|
||||
|
||||
#![recursion_limit="256"]
|
||||
|
||||
#[cfg(unix)]
|
||||
extern crate libc;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
extern crate rustc;
|
||||
extern crate rustc_codegen_utils;
|
||||
extern crate rustc_allocator;
|
||||
extern crate rustc_borrowck;
|
||||
extern crate rustc_incremental;
|
||||
extern crate rustc_traits;
|
||||
#[macro_use]
|
||||
extern crate rustc_data_structures;
|
||||
extern crate rustc_errors;
|
||||
extern crate rustc_lint;
|
||||
extern crate rustc_metadata;
|
||||
extern crate rustc_mir;
|
||||
extern crate rustc_passes;
|
||||
extern crate rustc_plugin;
|
||||
extern crate rustc_privacy;
|
||||
extern crate rustc_rayon as rayon;
|
||||
extern crate rustc_resolve;
|
||||
extern crate rustc_typeck;
|
||||
extern crate smallvec;
|
||||
extern crate serialize;
|
||||
extern crate syntax;
|
||||
extern crate syntax_pos;
|
||||
extern crate syntax_ext;
|
||||
|
||||
pub mod passes;
|
||||
pub mod profile;
|
||||
pub mod util;
|
||||
pub mod proc_macro_decls;
|
296
src/librustc_interface/passes.rs
Normal file
296
src/librustc_interface/passes.rs
Normal file
@ -0,0 +1,296 @@
|
||||
use util;
|
||||
use proc_macro_decls;
|
||||
|
||||
use rustc::dep_graph::DepGraph;
|
||||
use rustc::hir;
|
||||
use rustc::hir::lowering::lower_crate;
|
||||
use rustc::hir::def_id::{CrateNum, LOCAL_CRATE};
|
||||
use rustc::lint;
|
||||
use rustc::middle::{self, reachable, resolve_lifetime, stability};
|
||||
use rustc::middle::privacy::AccessLevels;
|
||||
use rustc::ty::{self, AllArenas, Resolutions, TyCtxt};
|
||||
use rustc::ty::steal::Steal;
|
||||
use rustc::traits;
|
||||
use rustc::util::common::{time, ErrorReported};
|
||||
use rustc::util::profiling::ProfileCategory;
|
||||
use rustc::session::{CompileResult, CrateDisambiguator, Session};
|
||||
use rustc::session::config::{self, Input, OutputFilenames, OutputType};
|
||||
use rustc::session::search_paths::PathKind;
|
||||
use rustc_allocator as allocator;
|
||||
use rustc_borrowck as borrowck;
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
use rustc_data_structures::fingerprint::Fingerprint;
|
||||
use rustc_data_structures::stable_hasher::StableHasher;
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
use rustc_incremental;
|
||||
use rustc_metadata::creader::CrateLoader;
|
||||
use rustc_metadata::cstore::{self, CStore};
|
||||
use rustc_mir as mir;
|
||||
use rustc_passes::{self, ast_validation, hir_stats, loops, rvalue_promotion, layout_test};
|
||||
use rustc_plugin as plugin;
|
||||
use rustc_plugin::registry::Registry;
|
||||
use rustc_privacy;
|
||||
use rustc_resolve::{Resolver, ResolverArenas};
|
||||
use rustc_traits;
|
||||
use rustc_typeck as typeck;
|
||||
use syntax::{self, ast, attr, diagnostics, visit};
|
||||
use syntax::early_buffered_lints::BufferedEarlyLint;
|
||||
use syntax::ext::base::ExtCtxt;
|
||||
use syntax::mut_visit::MutVisitor;
|
||||
use syntax::parse::{self, PResult};
|
||||
use syntax::util::node_count::NodeCounter;
|
||||
use syntax::util::lev_distance::find_best_match_for_name;
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax_pos::{FileName, hygiene};
|
||||
use syntax_ext;
|
||||
|
||||
use serialize::json;
|
||||
|
||||
use std::any::Any;
|
||||
use std::env;
|
||||
use std::ffi::OsString;
|
||||
use std::fs;
|
||||
use std::io::{self, Write};
|
||||
use std::iter;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::mpsc;
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
use std::mem;
|
||||
use std::ops::Generator;
|
||||
|
||||
/// Returns all the paths that correspond to generated files.
|
||||
pub fn generated_output_paths(
|
||||
sess: &Session,
|
||||
outputs: &OutputFilenames,
|
||||
exact_name: bool,
|
||||
crate_name: &str,
|
||||
) -> Vec<PathBuf> {
|
||||
let mut out_filenames = Vec::new();
|
||||
for output_type in sess.opts.output_types.keys() {
|
||||
let file = outputs.path(*output_type);
|
||||
match *output_type {
|
||||
// If the filename has been overridden using `-o`, it will not be modified
|
||||
// by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
|
||||
OutputType::Exe if !exact_name => for crate_type in sess.crate_types.borrow().iter() {
|
||||
let p = ::rustc_codegen_utils::link::filename_for_input(
|
||||
sess,
|
||||
*crate_type,
|
||||
crate_name,
|
||||
outputs,
|
||||
);
|
||||
out_filenames.push(p);
|
||||
},
|
||||
OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
|
||||
// Don't add the dep-info output when omitting it from dep-info targets
|
||||
}
|
||||
_ => {
|
||||
out_filenames.push(file);
|
||||
}
|
||||
}
|
||||
}
|
||||
out_filenames
|
||||
}
|
||||
|
||||
// Runs `f` on every output file path and returns the first non-None result, or None if `f`
|
||||
// returns None for every file path.
|
||||
fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
|
||||
where
|
||||
F: Fn(&PathBuf) -> Option<T>,
|
||||
{
|
||||
for output_path in output_paths {
|
||||
if let Some(result) = f(output_path) {
|
||||
return Some(result);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
|
||||
let input_path = input_path.canonicalize().ok();
|
||||
if input_path.is_none() {
|
||||
return false;
|
||||
}
|
||||
let check = |output_path: &PathBuf| {
|
||||
if output_path.canonicalize().ok() == input_path {
|
||||
Some(())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
check_output(output_paths, check).is_some()
|
||||
}
|
||||
|
||||
pub fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
|
||||
let check = |output_path: &PathBuf| {
|
||||
if output_path.is_dir() {
|
||||
Some(output_path.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
check_output(output_paths, check)
|
||||
}
|
||||
|
||||
fn escape_dep_filename(filename: &FileName) -> String {
|
||||
// Apparently clang and gcc *only* escape spaces:
|
||||
// http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
|
||||
filename.to_string().replace(" ", "\\ ")
|
||||
}
|
||||
|
||||
pub fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &[PathBuf]) {
|
||||
// Write out dependency rules to the dep-info file if requested
|
||||
if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
|
||||
return;
|
||||
}
|
||||
let deps_filename = outputs.path(OutputType::DepInfo);
|
||||
|
||||
let result = (|| -> io::Result<()> {
|
||||
// Build a list of files used to compile the output and
|
||||
// write Makefile-compatible dependency rules
|
||||
let files: Vec<String> = sess.source_map()
|
||||
.files()
|
||||
.iter()
|
||||
.filter(|fmap| fmap.is_real_file())
|
||||
.filter(|fmap| !fmap.is_imported())
|
||||
.map(|fmap| escape_dep_filename(&fmap.name))
|
||||
.collect();
|
||||
let mut file = fs::File::create(&deps_filename)?;
|
||||
for path in out_filenames {
|
||||
writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
|
||||
}
|
||||
|
||||
// Emit a fake target for each input file to the compilation. This
|
||||
// prevents `make` from spitting out an error if a file is later
|
||||
// deleted. For more info see #28735
|
||||
for path in files {
|
||||
writeln!(file, "{}:", path)?;
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
if let Err(e) = result {
|
||||
sess.fatal(&format!(
|
||||
"error writing dependencies to `{}`: {}",
|
||||
deps_filename.display(),
|
||||
e
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn provide(providers: &mut ty::query::Providers) {
|
||||
providers.analysis = analysis;
|
||||
proc_macro_decls::provide(providers);
|
||||
}
|
||||
|
||||
fn analysis<'tcx>(
|
||||
tcx: TyCtxt<'_, 'tcx, 'tcx>,
|
||||
cnum: CrateNum,
|
||||
) -> Result<(), ErrorReported> {
|
||||
assert_eq!(cnum, LOCAL_CRATE);
|
||||
|
||||
let sess = tcx.sess;
|
||||
|
||||
parallel!({
|
||||
time(sess, "looking for entry point", || {
|
||||
middle::entry::find_entry_point(tcx)
|
||||
});
|
||||
|
||||
time(sess, "looking for plugin registrar", || {
|
||||
plugin::build::find_plugin_registrar(tcx)
|
||||
});
|
||||
|
||||
time(sess, "looking for derive registrar", || {
|
||||
proc_macro_decls::find(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "loop checking", || loops::check_crate(tcx));
|
||||
}, {
|
||||
time(sess, "attribute checking", || {
|
||||
hir::check_attr::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "stability checking", || {
|
||||
stability::check_unstable_api_usage(tcx)
|
||||
});
|
||||
});
|
||||
|
||||
// passes are timed inside typeck
|
||||
typeck::check_crate(tcx)?;
|
||||
|
||||
time(sess, "misc checking", || {
|
||||
parallel!({
|
||||
time(sess, "rvalue promotion", || {
|
||||
rvalue_promotion::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "intrinsic checking", || {
|
||||
middle::intrinsicck::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "match checking", || mir::matchck_crate(tcx));
|
||||
}, {
|
||||
// this must run before MIR dump, because
|
||||
// "not all control paths return a value" is reported here.
|
||||
//
|
||||
// maybe move the check to a MIR pass?
|
||||
time(sess, "liveness checking", || {
|
||||
middle::liveness::check_crate(tcx)
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// Abort so we don't try to construct MIR with liveness errors.
|
||||
// We also won't want to continue with errors from rvalue promotion
|
||||
tcx.sess.abort_if_errors();
|
||||
|
||||
time(sess, "borrow checking", || {
|
||||
if tcx.use_ast_borrowck() {
|
||||
borrowck::check_crate(tcx);
|
||||
}
|
||||
});
|
||||
|
||||
time(sess,
|
||||
"MIR borrow checking",
|
||||
|| tcx.par_body_owners(|def_id| { tcx.ensure().mir_borrowck(def_id); }));
|
||||
|
||||
time(sess, "dumping chalk-like clauses", || {
|
||||
rustc_traits::lowering::dump_program_clauses(tcx);
|
||||
});
|
||||
|
||||
time(sess, "MIR effect checking", || {
|
||||
for def_id in tcx.body_owners() {
|
||||
mir::transform::check_unsafety::check_unsafety(tcx, def_id)
|
||||
}
|
||||
});
|
||||
|
||||
time(sess, "layout testing", || layout_test::test_layout(tcx));
|
||||
|
||||
// Avoid overwhelming user with errors if borrow checking failed.
|
||||
// I'm not sure how helpful this is, to be honest, but it avoids
|
||||
// a
|
||||
// lot of annoying errors in the compile-fail tests (basically,
|
||||
// lint warnings and so on -- kindck used to do this abort, but
|
||||
// kindck is gone now). -nmatsakis
|
||||
if sess.err_count() > 0 {
|
||||
return Err(ErrorReported);
|
||||
}
|
||||
|
||||
time(sess, "misc checking", || {
|
||||
parallel!({
|
||||
time(sess, "privacy checking", || {
|
||||
rustc_privacy::check_crate(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "death checking", || middle::dead::check_crate(tcx));
|
||||
}, {
|
||||
time(sess, "unused lib feature checking", || {
|
||||
stability::check_unused_or_stable_features(tcx)
|
||||
});
|
||||
}, {
|
||||
time(sess, "lint checking", || lint::check_crate(tcx));
|
||||
});
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
702
src/librustc_interface/util.rs
Normal file
702
src/librustc_interface/util.rs
Normal file
@ -0,0 +1,702 @@
|
||||
use rustc::session::config::{Input, OutputFilenames, ErrorOutputType};
|
||||
use rustc::session::{self, config, early_error, filesearch, Session, DiagnosticOutput};
|
||||
use rustc::session::CrateDisambiguator;
|
||||
use rustc::ty;
|
||||
use rustc::lint;
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
use rustc_data_structures::sync::{Lock, Lrc};
|
||||
use rustc_data_structures::stable_hasher::StableHasher;
|
||||
use rustc_data_structures::fingerprint::Fingerprint;
|
||||
use rustc_data_structures::thin_vec::ThinVec;
|
||||
use rustc_data_structures::fx::{FxHashSet, FxHashMap};
|
||||
use rustc_errors::registry::Registry;
|
||||
use rustc_lint;
|
||||
use rustc_metadata::dynamic_lib::DynamicLibrary;
|
||||
use rustc_mir;
|
||||
use rustc_passes;
|
||||
use rustc_plugin;
|
||||
use rustc_privacy;
|
||||
use rustc_resolve;
|
||||
use rustc_typeck;
|
||||
use std::collections::HashSet;
|
||||
use std::env;
|
||||
use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
|
||||
use std::io::{self, Write};
|
||||
use std::mem;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex, Once};
|
||||
use std::ops::DerefMut;
|
||||
use smallvec::SmallVec;
|
||||
use syntax::ptr::P;
|
||||
use syntax::mut_visit::{*, MutVisitor, visit_clobber};
|
||||
use syntax::ast::BlockCheckMode;
|
||||
use syntax::util::lev_distance::find_best_match_for_name;
|
||||
use syntax::source_map::{FileLoader, RealFileLoader, SourceMap};
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax::{self, ast, attr};
|
||||
#[cfg(not(parallel_compiler))]
|
||||
use std::{thread, panic};
|
||||
|
||||
pub fn diagnostics_registry() -> Registry {
|
||||
let mut all_errors = Vec::new();
|
||||
all_errors.extend_from_slice(&rustc::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_typeck::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_resolve::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_privacy::DIAGNOSTICS);
|
||||
// FIXME: need to figure out a way to get these back in here
|
||||
// all_errors.extend_from_slice(get_codegen_backend(sess).diagnostics());
|
||||
all_errors.extend_from_slice(&rustc_metadata::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_passes::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_plugin::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&rustc_mir::DIAGNOSTICS);
|
||||
all_errors.extend_from_slice(&syntax::DIAGNOSTICS);
|
||||
|
||||
Registry::new(&all_errors)
|
||||
}
|
||||
|
||||
/// Adds `target_feature = "..."` cfgs for a variety of platform
|
||||
/// specific features (SSE, NEON etc.).
|
||||
///
|
||||
/// This is performed by checking whether a whitelisted set of
|
||||
/// features is available on the target machine, by querying LLVM.
|
||||
pub fn add_configuration(
|
||||
cfg: &mut ast::CrateConfig,
|
||||
sess: &Session,
|
||||
codegen_backend: &dyn CodegenBackend,
|
||||
) {
|
||||
let tf = Symbol::intern("target_feature");
|
||||
|
||||
cfg.extend(
|
||||
codegen_backend
|
||||
.target_features(sess)
|
||||
.into_iter()
|
||||
.map(|feat| (tf, Some(feat))),
|
||||
);
|
||||
|
||||
if sess.crt_static_feature() {
|
||||
cfg.insert((tf, Some(Symbol::intern("crt-static"))));
|
||||
}
|
||||
}
|
||||
|
||||
fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
|
||||
let lib = DynamicLibrary::open(Some(path)).unwrap_or_else(|err| {
|
||||
let err = format!("couldn't load codegen backend {:?}: {:?}", path, err);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
unsafe {
|
||||
match lib.symbol("__rustc_codegen_backend") {
|
||||
Ok(f) => {
|
||||
mem::forget(lib);
|
||||
mem::transmute::<*mut u8, _>(f)
|
||||
}
|
||||
Err(e) => {
|
||||
let err = format!("couldn't load codegen backend as it \
|
||||
doesn't export the `__rustc_codegen_backend` \
|
||||
symbol: {:?}", e);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
|
||||
static INIT: Once = Once::new();
|
||||
|
||||
static mut LOAD: fn() -> Box<dyn CodegenBackend> = || unreachable!();
|
||||
|
||||
INIT.call_once(|| {
|
||||
let codegen_name = sess.opts.debugging_opts.codegen_backend.as_ref()
|
||||
.unwrap_or(&sess.target.target.options.codegen_backend);
|
||||
let backend = match &codegen_name[..] {
|
||||
"metadata_only" => {
|
||||
rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
|
||||
}
|
||||
filename if filename.contains(".") => {
|
||||
load_backend_from_dylib(filename.as_ref())
|
||||
}
|
||||
codegen_name => get_codegen_sysroot(codegen_name),
|
||||
};
|
||||
|
||||
unsafe {
|
||||
LOAD = backend;
|
||||
}
|
||||
});
|
||||
let backend = unsafe { LOAD() };
|
||||
backend.init(sess);
|
||||
backend
|
||||
}
|
||||
|
||||
pub fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend> {
|
||||
// For now we only allow this function to be called once as it'll dlopen a
|
||||
// few things, which seems to work best if we only do that once. In
|
||||
// general this assertion never trips due to the once guard in `get_codegen_backend`,
|
||||
// but there's a few manual calls to this function in this file we protect
|
||||
// against.
|
||||
static LOADED: AtomicBool = AtomicBool::new(false);
|
||||
assert!(!LOADED.fetch_or(true, Ordering::SeqCst),
|
||||
"cannot load the default codegen backend twice");
|
||||
|
||||
let target = session::config::host_triple();
|
||||
let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
|
||||
let path = current_dll_path()
|
||||
.and_then(|s| s.canonicalize().ok());
|
||||
if let Some(dll) = path {
|
||||
// use `parent` twice to chop off the file name and then also the
|
||||
// directory containing the dll which should be either `lib` or `bin`.
|
||||
if let Some(path) = dll.parent().and_then(|p| p.parent()) {
|
||||
// The original `path` pointed at the `rustc_driver` crate's dll.
|
||||
// Now that dll should only be in one of two locations. The first is
|
||||
// in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
|
||||
// other is the target's libdir, for example
|
||||
// `$sysroot/lib/rustlib/$target/lib/*.dll`.
|
||||
//
|
||||
// We don't know which, so let's assume that if our `path` above
|
||||
// ends in `$target` we *could* be in the target libdir, and always
|
||||
// assume that we may be in the main libdir.
|
||||
sysroot_candidates.push(path.to_owned());
|
||||
|
||||
if path.ends_with(target) {
|
||||
sysroot_candidates.extend(path.parent() // chop off `$target`
|
||||
.and_then(|p| p.parent()) // chop off `rustlib`
|
||||
.and_then(|p| p.parent()) // chop off `lib`
|
||||
.map(|s| s.to_owned()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let sysroot = sysroot_candidates.iter()
|
||||
.map(|sysroot| {
|
||||
let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
|
||||
sysroot.join(libdir).with_file_name(
|
||||
option_env!("CFG_CODEGEN_BACKENDS_DIR").unwrap_or("codegen-backends"))
|
||||
})
|
||||
.filter(|f| {
|
||||
info!("codegen backend candidate: {}", f.display());
|
||||
f.exists()
|
||||
})
|
||||
.next();
|
||||
let sysroot = sysroot.unwrap_or_else(|| {
|
||||
let candidates = sysroot_candidates.iter()
|
||||
.map(|p| p.display().to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n* ");
|
||||
let err = format!("failed to find a `codegen-backends` folder \
|
||||
in the sysroot candidates:\n* {}", candidates);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
info!("probing {} for a codegen backend", sysroot.display());
|
||||
|
||||
let d = sysroot.read_dir().unwrap_or_else(|e| {
|
||||
let err = format!("failed to load default codegen backend, couldn't \
|
||||
read `{}`: {}", sysroot.display(), e);
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
});
|
||||
|
||||
let mut file: Option<PathBuf> = None;
|
||||
|
||||
let expected_name = format!("rustc_codegen_llvm-{}", backend_name);
|
||||
for entry in d.filter_map(|e| e.ok()) {
|
||||
let path = entry.path();
|
||||
let filename = match path.file_name().and_then(|s| s.to_str()) {
|
||||
Some(s) => s,
|
||||
None => continue,
|
||||
};
|
||||
if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
|
||||
continue
|
||||
}
|
||||
let name = &filename[DLL_PREFIX.len() .. filename.len() - DLL_SUFFIX.len()];
|
||||
if name != expected_name {
|
||||
continue
|
||||
}
|
||||
if let Some(ref prev) = file {
|
||||
let err = format!("duplicate codegen backends found\n\
|
||||
first: {}\n\
|
||||
second: {}\n\
|
||||
", prev.display(), path.display());
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
file = Some(path.clone());
|
||||
}
|
||||
|
||||
match file {
|
||||
Some(ref s) => return load_backend_from_dylib(s),
|
||||
None => {
|
||||
let err = format!("failed to load default codegen backend for `{}`, \
|
||||
no appropriate codegen dylib found in `{}`",
|
||||
backend_name, sysroot.display());
|
||||
early_error(ErrorOutputType::default(), &err);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn current_dll_path() -> Option<PathBuf> {
|
||||
use std::ffi::{OsStr, CStr};
|
||||
use std::os::unix::prelude::*;
|
||||
|
||||
unsafe {
|
||||
let addr = current_dll_path as usize as *mut _;
|
||||
let mut info = mem::zeroed();
|
||||
if libc::dladdr(addr, &mut info) == 0 {
|
||||
info!("dladdr failed");
|
||||
return None
|
||||
}
|
||||
if info.dli_fname.is_null() {
|
||||
info!("dladdr returned null pointer");
|
||||
return None
|
||||
}
|
||||
let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
|
||||
let os = OsStr::from_bytes(bytes);
|
||||
Some(PathBuf::from(os))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn current_dll_path() -> Option<PathBuf> {
|
||||
use std::ffi::OsString;
|
||||
use std::os::windows::prelude::*;
|
||||
|
||||
extern "system" {
|
||||
fn GetModuleHandleExW(dwFlags: u32,
|
||||
lpModuleName: usize,
|
||||
phModule: *mut usize) -> i32;
|
||||
fn GetModuleFileNameW(hModule: usize,
|
||||
lpFilename: *mut u16,
|
||||
nSize: u32) -> u32;
|
||||
}
|
||||
|
||||
const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
|
||||
|
||||
unsafe {
|
||||
let mut module = 0;
|
||||
let r = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
|
||||
current_dll_path as usize,
|
||||
&mut module);
|
||||
if r == 0 {
|
||||
info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
let mut space = Vec::with_capacity(1024);
|
||||
let r = GetModuleFileNameW(module,
|
||||
space.as_mut_ptr(),
|
||||
space.capacity() as u32);
|
||||
if r == 0 {
|
||||
info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
let r = r as usize;
|
||||
if r >= space.capacity() {
|
||||
info!("our buffer was too small? {}",
|
||||
io::Error::last_os_error());
|
||||
return None
|
||||
}
|
||||
space.set_len(r);
|
||||
let os = OsString::from_wide(&space);
|
||||
Some(PathBuf::from(os))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator {
|
||||
use std::hash::Hasher;
|
||||
|
||||
// The crate_disambiguator is a 128 bit hash. The disambiguator is fed
|
||||
// into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
|
||||
// debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
|
||||
// should still be safe enough to avoid collisions in practice.
|
||||
let mut hasher = StableHasher::<Fingerprint>::new();
|
||||
|
||||
let mut metadata = session.opts.cg.metadata.clone();
|
||||
// We don't want the crate_disambiguator to dependent on the order
|
||||
// -C metadata arguments, so sort them:
|
||||
metadata.sort();
|
||||
// Every distinct -C metadata value is only incorporated once:
|
||||
metadata.dedup();
|
||||
|
||||
hasher.write(b"metadata");
|
||||
for s in &metadata {
|
||||
// Also incorporate the length of a metadata string, so that we generate
|
||||
// different values for `-Cmetadata=ab -Cmetadata=c` and
|
||||
// `-Cmetadata=a -Cmetadata=bc`
|
||||
hasher.write_usize(s.len());
|
||||
hasher.write(s.as_bytes());
|
||||
}
|
||||
|
||||
// Also incorporate crate type, so that we don't get symbol conflicts when
|
||||
// linking against a library of the same name, if this is an executable.
|
||||
let is_exe = session
|
||||
.crate_types
|
||||
.borrow()
|
||||
.contains(&config::CrateType::Executable);
|
||||
hasher.write(if is_exe { b"exe" } else { b"lib" });
|
||||
|
||||
CrateDisambiguator::from(hasher.finish())
|
||||
}
|
||||
|
||||
pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
|
||||
// Unconditionally collect crate types from attributes to make them used
|
||||
let attr_types: Vec<config::CrateType> = attrs
|
||||
.iter()
|
||||
.filter_map(|a| {
|
||||
if a.check_name("crate_type") {
|
||||
match a.value_str() {
|
||||
Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib),
|
||||
Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib),
|
||||
Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib),
|
||||
Some(ref n) if *n == "lib" => Some(config::default_lib_output()),
|
||||
Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib),
|
||||
Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro),
|
||||
Some(ref n) if *n == "bin" => Some(config::CrateType::Executable),
|
||||
Some(ref n) => {
|
||||
let crate_types = vec![
|
||||
Symbol::intern("rlib"),
|
||||
Symbol::intern("dylib"),
|
||||
Symbol::intern("cdylib"),
|
||||
Symbol::intern("lib"),
|
||||
Symbol::intern("staticlib"),
|
||||
Symbol::intern("proc-macro"),
|
||||
Symbol::intern("bin")
|
||||
];
|
||||
|
||||
if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node {
|
||||
let span = spanned.span;
|
||||
let lev_candidate = find_best_match_for_name(
|
||||
crate_types.iter(),
|
||||
&n.as_str(),
|
||||
None
|
||||
);
|
||||
if let Some(candidate) = lev_candidate {
|
||||
session.buffer_lint_with_diagnostic(
|
||||
lint::builtin::UNKNOWN_CRATE_TYPES,
|
||||
ast::CRATE_NODE_ID,
|
||||
span,
|
||||
"invalid `crate_type` value",
|
||||
lint::builtin::BuiltinLintDiagnostics::
|
||||
UnknownCrateTypes(
|
||||
span,
|
||||
"did you mean".to_string(),
|
||||
format!("\"{}\"", candidate)
|
||||
)
|
||||
);
|
||||
} else {
|
||||
session.buffer_lint(
|
||||
lint::builtin::UNKNOWN_CRATE_TYPES,
|
||||
ast::CRATE_NODE_ID,
|
||||
span,
|
||||
"invalid `crate_type` value"
|
||||
);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
None => None
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
// If we're generating a test executable, then ignore all other output
|
||||
// styles at all other locations
|
||||
if session.opts.test {
|
||||
return vec![config::CrateType::Executable];
|
||||
}
|
||||
|
||||
// Only check command line flags if present. If no types are specified by
|
||||
// command line, then reuse the empty `base` Vec to hold the types that
|
||||
// will be found in crate attributes.
|
||||
let mut base = session.opts.crate_types.clone();
|
||||
if base.is_empty() {
|
||||
base.extend(attr_types);
|
||||
if base.is_empty() {
|
||||
base.push(::rustc_codegen_utils::link::default_output_for_target(
|
||||
session,
|
||||
));
|
||||
} else {
|
||||
base.sort();
|
||||
base.dedup();
|
||||
}
|
||||
}
|
||||
|
||||
base.retain(|crate_type| {
|
||||
let res = !::rustc_codegen_utils::link::invalid_output_for_target(session, *crate_type);
|
||||
|
||||
if !res {
|
||||
session.warn(&format!(
|
||||
"dropping unsupported crate type `{}` for target `{}`",
|
||||
*crate_type, session.opts.target_triple
|
||||
));
|
||||
}
|
||||
|
||||
res
|
||||
});
|
||||
|
||||
base
|
||||
}
|
||||
|
||||
pub fn build_output_filenames(
|
||||
input: &Input,
|
||||
odir: &Option<PathBuf>,
|
||||
ofile: &Option<PathBuf>,
|
||||
attrs: &[ast::Attribute],
|
||||
sess: &Session,
|
||||
) -> OutputFilenames {
|
||||
match *ofile {
|
||||
None => {
|
||||
// "-" as input file will cause the parser to read from stdin so we
|
||||
// have to make up a name
|
||||
// We want to toss everything after the final '.'
|
||||
let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
|
||||
|
||||
// If a crate name is present, we use it as the link name
|
||||
let stem = sess.opts
|
||||
.crate_name
|
||||
.clone()
|
||||
.or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
|
||||
.unwrap_or_else(|| input.filestem().to_owned());
|
||||
|
||||
OutputFilenames {
|
||||
out_directory: dirpath,
|
||||
out_filestem: stem,
|
||||
single_output_file: None,
|
||||
extra: sess.opts.cg.extra_filename.clone(),
|
||||
outputs: sess.opts.output_types.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
Some(ref out_file) => {
|
||||
let unnamed_output_types = sess.opts
|
||||
.output_types
|
||||
.values()
|
||||
.filter(|a| a.is_none())
|
||||
.count();
|
||||
let ofile = if unnamed_output_types > 1 {
|
||||
sess.warn(
|
||||
"due to multiple output types requested, the explicitly specified \
|
||||
output file name will be adapted for each output type",
|
||||
);
|
||||
None
|
||||
} else {
|
||||
Some(out_file.clone())
|
||||
};
|
||||
if *odir != None {
|
||||
sess.warn("ignoring --out-dir flag due to -o flag");
|
||||
}
|
||||
if !sess.opts.cg.extra_filename.is_empty() {
|
||||
sess.warn("ignoring -C extra-filename flag due to -o flag");
|
||||
}
|
||||
|
||||
OutputFilenames {
|
||||
out_directory: out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
|
||||
out_filestem: out_file
|
||||
.file_stem()
|
||||
.unwrap_or_default()
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_string(),
|
||||
single_output_file: ofile,
|
||||
extra: sess.opts.cg.extra_filename.clone(),
|
||||
outputs: sess.opts.output_types.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
|
||||
//
|
||||
// FIXME: Currently the `everybody_loops` transformation is not applied to:
|
||||
// * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
|
||||
// waiting for miri to fix that.
|
||||
// * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
|
||||
// Solving this may require `!` to implement every trait, which relies on the an even more
|
||||
// ambitious form of the closed RFC #1637. See also [#34511].
|
||||
//
|
||||
// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
|
||||
pub struct ReplaceBodyWithLoop<'a> {
|
||||
within_static_or_const: bool,
|
||||
nested_blocks: Option<Vec<ast::Block>>,
|
||||
sess: &'a Session,
|
||||
}
|
||||
|
||||
impl<'a> ReplaceBodyWithLoop<'a> {
|
||||
pub fn new(sess: &'a Session) -> ReplaceBodyWithLoop<'a> {
|
||||
ReplaceBodyWithLoop {
|
||||
within_static_or_const: false,
|
||||
nested_blocks: None,
|
||||
sess
|
||||
}
|
||||
}
|
||||
|
||||
fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
|
||||
let old_const = mem::replace(&mut self.within_static_or_const, is_const);
|
||||
let old_blocks = self.nested_blocks.take();
|
||||
let ret = action(self);
|
||||
self.within_static_or_const = old_const;
|
||||
self.nested_blocks = old_blocks;
|
||||
ret
|
||||
}
|
||||
|
||||
fn should_ignore_fn(ret_ty: &ast::FnDecl) -> bool {
|
||||
if let ast::FunctionRetTy::Ty(ref ty) = ret_ty.output {
|
||||
fn involves_impl_trait(ty: &ast::Ty) -> bool {
|
||||
match ty.node {
|
||||
ast::TyKind::ImplTrait(..) => true,
|
||||
ast::TyKind::Slice(ref subty) |
|
||||
ast::TyKind::Array(ref subty, _) |
|
||||
ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) |
|
||||
ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) |
|
||||
ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
|
||||
ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
|
||||
ast::TyKind::Path(_, ref path) => path.segments.iter().any(|seg| {
|
||||
match seg.args.as_ref().map(|generic_arg| &**generic_arg) {
|
||||
None => false,
|
||||
Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
|
||||
let types = data.args.iter().filter_map(|arg| match arg {
|
||||
ast::GenericArg::Type(ty) => Some(ty),
|
||||
_ => None,
|
||||
});
|
||||
any_involves_impl_trait(types.into_iter()) ||
|
||||
any_involves_impl_trait(data.bindings.iter().map(|b| &b.ty))
|
||||
},
|
||||
Some(&ast::GenericArgs::Parenthesized(ref data)) => {
|
||||
any_involves_impl_trait(data.inputs.iter()) ||
|
||||
any_involves_impl_trait(data.output.iter())
|
||||
}
|
||||
}
|
||||
}),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
|
||||
it.any(|subty| involves_impl_trait(subty))
|
||||
}
|
||||
|
||||
involves_impl_trait(ty)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> MutVisitor for ReplaceBodyWithLoop<'a> {
|
||||
fn visit_item_kind(&mut self, i: &mut ast::ItemKind) {
|
||||
let is_const = match i {
|
||||
ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
|
||||
ast::ItemKind::Fn(ref decl, ref header, _, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_visit_item_kind(i, s))
|
||||
}
|
||||
|
||||
fn flat_map_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
|
||||
let is_const = match i.node {
|
||||
ast::TraitItemKind::Const(..) => true,
|
||||
ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_flat_map_trait_item(i, s))
|
||||
}
|
||||
|
||||
fn flat_map_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
|
||||
let is_const = match i.node {
|
||||
ast::ImplItemKind::Const(..) => true,
|
||||
ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
|
||||
header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
|
||||
_ => false,
|
||||
};
|
||||
self.run(is_const, |s| noop_flat_map_impl_item(i, s))
|
||||
}
|
||||
|
||||
fn visit_anon_const(&mut self, c: &mut ast::AnonConst) {
|
||||
self.run(true, |s| noop_visit_anon_const(c, s))
|
||||
}
|
||||
|
||||
fn visit_block(&mut self, b: &mut P<ast::Block>) {
|
||||
fn stmt_to_block(rules: ast::BlockCheckMode,
|
||||
s: Option<ast::Stmt>,
|
||||
sess: &Session) -> ast::Block {
|
||||
ast::Block {
|
||||
stmts: s.into_iter().collect(),
|
||||
rules,
|
||||
id: sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
}
|
||||
}
|
||||
|
||||
fn block_to_stmt(b: ast::Block, sess: &Session) -> ast::Stmt {
|
||||
let expr = P(ast::Expr {
|
||||
id: sess.next_node_id(),
|
||||
node: ast::ExprKind::Block(P(b), None),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
attrs: ThinVec::new(),
|
||||
});
|
||||
|
||||
ast::Stmt {
|
||||
id: sess.next_node_id(),
|
||||
node: ast::StmtKind::Expr(expr),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
}
|
||||
}
|
||||
|
||||
let empty_block = stmt_to_block(BlockCheckMode::Default, None, self.sess);
|
||||
let loop_expr = P(ast::Expr {
|
||||
node: ast::ExprKind::Loop(P(empty_block), None),
|
||||
id: self.sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
attrs: ThinVec::new(),
|
||||
});
|
||||
|
||||
let loop_stmt = ast::Stmt {
|
||||
id: self.sess.next_node_id(),
|
||||
span: syntax_pos::DUMMY_SP,
|
||||
node: ast::StmtKind::Expr(loop_expr),
|
||||
};
|
||||
|
||||
if self.within_static_or_const {
|
||||
noop_visit_block(b, self)
|
||||
} else {
|
||||
visit_clobber(b.deref_mut(), |b| {
|
||||
let mut stmts = vec![];
|
||||
for s in b.stmts {
|
||||
let old_blocks = self.nested_blocks.replace(vec![]);
|
||||
|
||||
stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item()));
|
||||
|
||||
// we put a Some in there earlier with that replace(), so this is valid
|
||||
let new_blocks = self.nested_blocks.take().unwrap();
|
||||
self.nested_blocks = old_blocks;
|
||||
stmts.extend(new_blocks.into_iter().map(|b| block_to_stmt(b, &self.sess)));
|
||||
}
|
||||
|
||||
let mut new_block = ast::Block {
|
||||
stmts,
|
||||
..b
|
||||
};
|
||||
|
||||
if let Some(old_blocks) = self.nested_blocks.as_mut() {
|
||||
//push our fresh block onto the cache and yield an empty block with `loop {}`
|
||||
if !new_block.stmts.is_empty() {
|
||||
old_blocks.push(new_block);
|
||||
}
|
||||
|
||||
stmt_to_block(b.rules, Some(loop_stmt), self.sess)
|
||||
} else {
|
||||
//push `loop {}` onto the end of our fresh block and yield that
|
||||
new_block.stmts.push(loop_stmt);
|
||||
|
||||
new_block
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// in general the pretty printer processes unexpanded code, so
|
||||
// we override the default `visit_mac` method which panics.
|
||||
fn visit_mac(&mut self, mac: &mut ast::Mac) {
|
||||
noop_visit_mac(mac, self)
|
||||
}
|
||||
}
|
@ -131,7 +131,7 @@ use std::ops::{self, Deref};
|
||||
use std::slice;
|
||||
|
||||
use crate::require_c_abi_if_c_variadic;
|
||||
use crate::session::{CompileIncomplete, Session};
|
||||
use crate::session::Session;
|
||||
use crate::session::config::EntryFnType;
|
||||
use crate::TypeAndSubsts;
|
||||
use crate::lint;
|
||||
@ -711,12 +711,12 @@ fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId)
|
||||
tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
|
||||
}
|
||||
|
||||
pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
|
||||
pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
|
||||
tcx.typeck_item_bodies(LOCAL_CRATE)
|
||||
}
|
||||
|
||||
fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
|
||||
-> Result<(), CompileIncomplete>
|
||||
-> Result<(), ErrorReported>
|
||||
{
|
||||
debug_assert!(crate_num == LOCAL_CRATE);
|
||||
Ok(tcx.sess.track_errors(|| {
|
||||
|
@ -102,7 +102,7 @@ use rustc::infer::InferOk;
|
||||
use rustc::lint;
|
||||
use rustc::middle;
|
||||
use rustc::session;
|
||||
use rustc::session::CompileIncomplete;
|
||||
use rustc::util::common::ErrorReported;
|
||||
use rustc::session::config::{EntryFnType, nightly_options};
|
||||
use rustc::traits::{ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt};
|
||||
use rustc::ty::subst::SubstsRef;
|
||||
@ -315,7 +315,7 @@ pub fn provide(providers: &mut Providers<'_>) {
|
||||
}
|
||||
|
||||
pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
|
||||
-> Result<(), CompileIncomplete>
|
||||
-> Result<(), ErrorReported>
|
||||
{
|
||||
tcx.sess.profiler(|p| p.start_activity(ProfileCategory::TypeChecking));
|
||||
|
||||
@ -324,7 +324,6 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
|
||||
tcx.sess.track_errors(|| {
|
||||
time(tcx.sess, "type collecting", ||
|
||||
collect::collect_item_types(tcx));
|
||||
|
||||
})?;
|
||||
|
||||
if tcx.features().rustc_attrs {
|
||||
@ -362,7 +361,11 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
|
||||
|
||||
tcx.sess.profiler(|p| p.end_activity(ProfileCategory::TypeChecking));
|
||||
|
||||
tcx.sess.compile_status()
|
||||
if tcx.sess.err_count() == 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(ErrorReported)
|
||||
}
|
||||
}
|
||||
|
||||
/// A quasi-deprecated helper used in rustdoc and save-analysis to get
|
||||
|
@ -1,5 +1,5 @@
|
||||
use rustc_lint;
|
||||
use rustc_driver::{self, driver, target_features, abort_on_err};
|
||||
use rustc_driver::{driver, abort_on_err};
|
||||
use rustc::session::{self, config};
|
||||
use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CrateNum, LOCAL_CRATE};
|
||||
use rustc::hir::def::Def;
|
||||
@ -11,6 +11,7 @@ use rustc::hir::map as hir_map;
|
||||
use rustc::lint::{self, LintPass};
|
||||
use rustc::session::config::ErrorOutputType;
|
||||
use rustc::util::nodemap::{FxHashMap, FxHashSet};
|
||||
use rustc_interface::util;
|
||||
use rustc_resolve as resolve;
|
||||
use rustc_metadata::creader::CrateLoader;
|
||||
use rustc_metadata::cstore::CStore;
|
||||
@ -402,7 +403,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
|
||||
debugging_options.ui_testing);
|
||||
|
||||
let mut sess = session::build_session_(
|
||||
sessopts, cpath, diagnostic_handler, source_map,
|
||||
sessopts, cpath, diagnostic_handler, source_map, Default::default(),
|
||||
);
|
||||
|
||||
lint::builtin::HardwiredLints.get_lints()
|
||||
@ -422,12 +423,12 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
|
||||
lint::Allow);
|
||||
});
|
||||
|
||||
let codegen_backend = rustc_driver::get_codegen_backend(&sess);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
let cstore = Rc::new(CStore::new(codegen_backend.metadata_loader()));
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
|
||||
let mut cfg = config::build_configuration(&sess, config::parse_cfgspecs(cfgs));
|
||||
target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
util::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
sess.parse_sess.config = cfg;
|
||||
|
||||
let control = &driver::CompileController::basic();
|
||||
@ -481,23 +482,23 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
|
||||
|
||||
let mut arenas = AllArenas::new();
|
||||
let hir_map = hir_map::map_crate(&sess, &*cstore, &mut hir_forest, &defs);
|
||||
let output_filenames = driver::build_output_filenames(&input,
|
||||
let output_filenames = util::build_output_filenames(&input,
|
||||
&None,
|
||||
&None,
|
||||
&[],
|
||||
&sess);
|
||||
|
||||
let resolver = RefCell::new(resolver);
|
||||
abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
&sess,
|
||||
&*cstore,
|
||||
hir_map,
|
||||
resolutions,
|
||||
&mut arenas,
|
||||
&name,
|
||||
&output_filenames,
|
||||
|tcx, _, result| {
|
||||
driver::phase_3_run_analysis_passes(&*codegen_backend,
|
||||
control,
|
||||
&sess,
|
||||
&*cstore,
|
||||
hir_map,
|
||||
resolutions,
|
||||
&mut arenas,
|
||||
&name,
|
||||
&output_filenames,
|
||||
|tcx, _, result| {
|
||||
if result.is_err() {
|
||||
sess.fatal("Compilation failed, aborting rustdoc");
|
||||
}
|
||||
@ -615,6 +616,6 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
|
||||
ctxt.sess().abort_if_errors();
|
||||
|
||||
(krate, ctxt.renderinfo.into_inner(), render_options, passes)
|
||||
}), &sess)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
@ -30,6 +30,7 @@ extern crate rustc_lint;
|
||||
extern crate rustc_metadata;
|
||||
extern crate rustc_target;
|
||||
extern crate rustc_typeck;
|
||||
extern crate rustc_interface;
|
||||
extern crate serialize;
|
||||
extern crate syntax;
|
||||
extern crate syntax_pos;
|
||||
|
@ -2,9 +2,10 @@ use errors::{self, FatalError};
|
||||
use errors::emitter::ColorConfig;
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
use rustc_lint;
|
||||
use rustc_driver::{self, driver, target_features, Compilation};
|
||||
use rustc_driver::{self, driver, Compilation};
|
||||
use rustc_driver::driver::phase_2_configure_and_expand;
|
||||
use rustc_metadata::cstore::CStore;
|
||||
use rustc_interface::util;
|
||||
use rustc::hir;
|
||||
use rustc::hir::intravisit;
|
||||
use rustc::session::{self, CompileIncomplete, config};
|
||||
@ -70,15 +71,15 @@ pub fn run(mut options: Options) -> isize {
|
||||
Some(source_map.clone()));
|
||||
|
||||
let mut sess = session::build_session_(
|
||||
sessopts, Some(options.input), handler, source_map.clone(),
|
||||
sessopts, Some(options.input), handler, source_map.clone(), Default::default(),
|
||||
);
|
||||
let codegen_backend = rustc_driver::get_codegen_backend(&sess);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
let cstore = CStore::new(codegen_backend.metadata_loader());
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
|
||||
let mut cfg = config::build_configuration(&sess,
|
||||
config::parse_cfgspecs(options.cfgs.clone()));
|
||||
target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
util::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
sess.parse_sess.config = cfg;
|
||||
|
||||
let krate =
|
||||
@ -274,9 +275,9 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize,
|
||||
let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
|
||||
|
||||
let mut sess = session::build_session_(
|
||||
sessopts, None, diagnostic_handler, source_map,
|
||||
sessopts, None, diagnostic_handler, source_map, Default::default(),
|
||||
);
|
||||
let codegen_backend = rustc_driver::get_codegen_backend(&sess);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
let cstore = CStore::new(codegen_backend.metadata_loader());
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
|
||||
@ -305,7 +306,7 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize,
|
||||
let mut control = driver::CompileController::basic();
|
||||
|
||||
let mut cfg = config::build_configuration(&sess, config::parse_cfgspecs(cfgs.clone()));
|
||||
target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
util::add_configuration(&mut cfg, &sess, &*codegen_backend);
|
||||
sess.parse_sess.config = cfg;
|
||||
|
||||
let out = Some(outdir.lock().unwrap().path().join("rust_out"));
|
||||
|
@ -6,6 +6,7 @@ extern crate rustc_lint;
|
||||
extern crate rustc_metadata;
|
||||
extern crate rustc_errors;
|
||||
extern crate rustc_codegen_utils;
|
||||
extern crate rustc_interface;
|
||||
extern crate syntax;
|
||||
|
||||
use rustc::session::{build_session, Session};
|
||||
@ -14,6 +15,7 @@ use rustc::session::config::{Input, Options,
|
||||
use rustc_driver::driver::{self, compile_input, CompileController};
|
||||
use rustc_metadata::cstore::CStore;
|
||||
use rustc_errors::registry::Registry;
|
||||
use rustc_interface::util;
|
||||
use syntax::source_map::FileName;
|
||||
use rustc_codegen_utils::codegen_backend::CodegenBackend;
|
||||
|
||||
@ -45,7 +47,7 @@ fn main() {
|
||||
fn basic_sess(opts: Options) -> (Session, Rc<CStore>, Box<CodegenBackend>) {
|
||||
let descriptions = Registry::new(&rustc::DIAGNOSTICS);
|
||||
let sess = build_session(opts, None, descriptions);
|
||||
let codegen_backend = rustc_driver::get_codegen_backend(&sess);
|
||||
let codegen_backend = util::get_codegen_backend(&sess);
|
||||
let cstore = Rc::new(CStore::new(codegen_backend.metadata_loader()));
|
||||
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
|
||||
(sess, cstore, codegen_backend)
|
||||
|
@ -12,7 +12,7 @@ error[E0425]: cannot find value `no` in this scope
|
||||
3 | no
|
||||
| ^^ not found in this scope
|
||||
|
||||
thread '$DIR/failed-doctest-output.rs - OtherStruct (line 17)' panicked at 'couldn't compile the test', src/librustdoc/test.rs:351:13
|
||||
thread '$DIR/failed-doctest-output.rs - OtherStruct (line 17)' panicked at 'couldn't compile the test', src/librustdoc/test.rs:352:13
|
||||
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
|
||||
|
||||
---- $DIR/failed-doctest-output.rs - SomeStruct (line 11) stdout ----
|
||||
@ -21,7 +21,7 @@ thread '$DIR/failed-doctest-output.rs - SomeStruct (line 11)' panicked at 'test
|
||||
thread 'main' panicked at 'oh no', $DIR/failed-doctest-output.rs:3:1
|
||||
note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
|
||||
|
||||
', src/librustdoc/test.rs:372:17
|
||||
', src/librustdoc/test.rs:373:17
|
||||
|
||||
|
||||
failures:
|
||||
|
@ -20,6 +20,7 @@ note: ...which requires checking which parts of `B` are promotable to static...
|
||||
LL | const B: i32 = A;
|
||||
| ^
|
||||
= note: ...which again requires const checking if rvalue is promotable to static `A`, completing the cycle
|
||||
= note: cycle used when running analysis passes on this crate
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user