//! This API is completely unstable and subject to change.
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
+#![feature(is_terminal)]
#![feature(once_cell)]
+#![feature(decl_macro)]
#![recursion_limit = "256"]
#![allow(rustc::potential_query_instability)]
#![deny(rustc::untranslatable_diagnostic)]
use rustc_errors::registry::{InvalidErrorCode, Registry};
use rustc_errors::{ErrorGuaranteed, PResult};
use rustc_feature::find_gated_cfg;
+use rustc_hir::def_id::LOCAL_CRATE;
use rustc_interface::util::{self, collect_crate_types, get_codegen_backend};
use rustc_interface::{interface, Queries};
use rustc_lint::LintStore;
-use rustc_log::stdout_isatty;
use rustc_metadata::locator;
use rustc_save_analysis as save;
use rustc_save_analysis::DumpHandler;
use std::env;
use std::ffi::OsString;
use std::fs;
-use std::io::{self, Read, Write};
+use std::io::{self, IsTerminal, Read, Write};
use std::panic::{self, catch_unwind};
use std::path::PathBuf;
use std::process::{self, Command, Stdio};
interface::run_compiler(config, |compiler| {
let sopts = &compiler.session().opts;
if sopts.describe_lints {
- let mut lint_store = rustc_lint::new_lint_store(
- sopts.unstable_opts.no_interleave_lints,
- compiler.session().enable_internal_lints(),
- );
+ let mut lint_store =
+ rustc_lint::new_lint_store(compiler.session().enable_internal_lints());
let registered_lints =
if let Some(register_lints) = compiler.register_lints() {
register_lints(compiler.session(), &mut lint_store);
compiler.input(),
&*expanded_crate,
*ppm,
- compiler.output_file().as_ref().map(|p| &**p),
+ compiler.output_file().as_deref(),
);
Ok(())
})?;
compiler.input(),
&krate,
*ppm,
- compiler.output_file().as_ref().map(|p| &**p),
+ compiler.output_file().as_deref(),
);
}
trace!("finished pretty-printing");
queries.global_ctxt()?.peek_mut().enter(|tcx| {
let result = tcx.analysis(());
if sess.opts.unstable_opts.save_analysis {
- let crate_name = queries.crate_name()?.peek().clone();
+ let crate_name = tcx.crate_name(LOCAL_CRATE);
sess.time("save_analysis", || {
save::process_crate(
tcx,
- &crate_name,
+ crate_name,
compiler.input(),
None,
- DumpHandler::new(
- compiler.output_dir().as_ref().map(|p| &**p),
- &crate_name,
- ),
+ DumpHandler::new(compiler.output_dir().as_deref(), crate_name),
)
});
}
}
text.push('\n');
}
- if stdout_isatty() {
+ if io::stdout().is_terminal() {
show_content_with_pager(&text);
} else {
print!("{}", text);
let crate_types = collect_crate_types(sess, attrs);
for &style in &crate_types {
let fname =
- rustc_session::output::filename_for_input(sess, style, &id, &t_outputs);
+ rustc_session::output::filename_for_input(sess, style, id, &t_outputs);
println!("{}", fname.file_name().unwrap().to_string_lossy());
}
}
// Any output here interferes with Cargo's parsing of other printed output
NativeStaticLibs => {}
LinkArgs => {}
+ SplitDebuginfo => {
+ use rustc_target::spec::SplitDebuginfo::{Off, Packed, Unpacked};
+
+ for split in &[Off, Packed, Unpacked] {
+ let stable = sess.target.options.supported_split_debuginfo.contains(split);
+ let unstable_ok = sess.unstable_options();
+ if stable || unstable_ok {
+ println!("{}", split);
+ }
+ }
+ }
}
}
Compilation::Stop
}
/// Prints version information
-pub fn version(binary: &str, matches: &getopts::Matches) {
+///
+/// NOTE: this is a macro to support drivers built at a different time than the main `rustc_driver` crate.
+pub macro version($binary: literal, $matches: expr) {
+ fn unw(x: Option<&str>) -> &str {
+ x.unwrap_or("unknown")
+ }
+ $crate::version_at_macro_invocation(
+ $binary,
+ $matches,
+ unw(option_env!("CFG_VERSION")),
+ unw(option_env!("CFG_VER_HASH")),
+ unw(option_env!("CFG_VER_DATE")),
+ unw(option_env!("CFG_RELEASE")),
+ )
+}
+
+#[doc(hidden)] // use the macro instead
+pub fn version_at_macro_invocation(
+ binary: &str,
+ matches: &getopts::Matches,
+ version: &str,
+ commit_hash: &str,
+ commit_date: &str,
+ release: &str,
+) {
let verbose = matches.opt_present("verbose");
- println!("{} {}", binary, util::version_str().unwrap_or("unknown version"));
+ println!("{} {}", binary, version);
if verbose {
- fn unw(x: Option<&str>) -> &str {
- x.unwrap_or("unknown")
- }
println!("binary: {}", binary);
- println!("commit-hash: {}", unw(util::commit_hash_str()));
- println!("commit-date: {}", unw(util::commit_date_str()));
+ println!("commit-hash: {}", commit_hash);
+ println!("commit-date: {}", commit_date);
println!("host: {}", config::host_triple());
- println!("release: {}", unw(util::release_str()));
+ println!("release: {}", release);
let debug_flags = matches.opt_strs("Z");
let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend="));
}
if matches.opt_present("version") {
- version("rustc", &matches);
+ version!("rustc", &matches);
return None;
}
false,
None,
false,
+ false,
));
let handler = rustc_errors::Handler::with_emitter(true, None, emitter);
format!("we would appreciate a bug report: {}", bug_report_url).into(),
format!(
"rustc {} running on {}",
- util::version_str().unwrap_or("unknown_version"),
+ util::version_str!().unwrap_or("unknown_version"),
config::host_triple()
)
.into(),
}
}
- // When an error signal (such as SIGABRT or SIGSEGV) is delivered to the
- // process, print a stack trace and then exit.
+ /// When an error signal (such as SIGABRT or SIGSEGV) is delivered to the
+ /// process, print a stack trace and then exit.
pub(super) fn install() {
unsafe {
const ALT_STACK_SIZE: usize = libc::MINSIGSTKSZ + 64 * 1024;
projects / rustc.git / blobdiff