diff options
Diffstat (limited to 'compiler/rustc_driver_impl/src/lib.rs')
| -rw-r--r-- | compiler/rustc_driver_impl/src/lib.rs | 123 |
1 files changed, 61 insertions, 62 deletions
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs index e49db64536f..d67fea7e9a4 100644 --- a/compiler/rustc_driver_impl/src/lib.rs +++ b/compiler/rustc_driver_impl/src/lib.rs @@ -27,7 +27,7 @@ use rustc_data_structures::profiling::{ use rustc_data_structures::sync::SeqCst; use rustc_errors::registry::{InvalidErrorCode, Registry}; use rustc_errors::{markdown, ColorConfig}; -use rustc_errors::{ErrorGuaranteed, Handler, PResult}; +use rustc_errors::{DiagCtxt, ErrorGuaranteed, PResult}; use rustc_feature::find_gated_cfg; use rustc_interface::util::{self, collect_crate_types, get_codegen_backend}; use rustc_interface::{interface, Queries}; @@ -38,7 +38,7 @@ use rustc_session::config::{nightly_options, CG_OPTIONS, Z_OPTIONS}; use rustc_session::config::{ErrorOutputType, Input, OutFileName, OutputType, TrimmedDefPaths}; use rustc_session::getopts::{self, Matches}; use rustc_session::lint::{Lint, LintId}; -use rustc_session::{config, EarlyErrorHandler, Session}; +use rustc_session::{config, EarlyDiagCtxt, Session}; use rustc_span::def_id::LOCAL_CRATE; use rustc_span::source_map::FileLoader; use rustc_span::symbol::sym; @@ -291,7 +291,7 @@ fn run_compiler( >, using_internal_features: Arc<std::sync::atomic::AtomicBool>, ) -> interface::Result<()> { - let mut default_handler = EarlyErrorHandler::new(ErrorOutputType::default()); + let mut default_early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default()); // Throw away the first argument, the name of the binary. // In case of at_args being empty, as might be the case by @@ -303,14 +303,14 @@ fn run_compiler( // the compiler with @empty_file as argv[0] and no more arguments. let at_args = at_args.get(1..).unwrap_or_default(); - let args = args::arg_expand_all(&default_handler, at_args); + let args = args::arg_expand_all(&default_early_dcx, at_args); - let Some(matches) = handle_options(&default_handler, &args) else { return Ok(()) }; + let Some(matches) = handle_options(&default_early_dcx, &args) else { return Ok(()) }; - let sopts = config::build_session_options(&mut default_handler, &matches); + let sopts = config::build_session_options(&mut default_early_dcx, &matches); if let Some(ref code) = matches.opt_str("explain") { - handle_explain(&default_handler, diagnostics_registry(), code, sopts.color); + handle_explain(&default_early_dcx, diagnostics_registry(), code, sopts.color); return Ok(()); } @@ -336,7 +336,7 @@ fn run_compiler( expanded_args: args, }; - let has_input = match make_input(&default_handler, &matches.free) { + let has_input = match make_input(&default_early_dcx, &matches.free) { Err(reported) => return Err(reported), Ok(Some(input)) => { config.input = input; @@ -345,7 +345,7 @@ fn run_compiler( Ok(None) => match matches.free.len() { 0 => false, // no input: we will exit early 1 => panic!("make_input should have provided valid inputs"), - _ => default_handler.early_error(format!( + _ => default_early_dcx.early_error(format!( "multiple input filenames provided (first two filenames are `{}` and `{}`)", matches.free[0], matches.free[1], )), @@ -354,8 +354,8 @@ fn run_compiler( callbacks.config(&mut config); - default_handler.abort_if_errors(); - drop(default_handler); + default_early_dcx.abort_if_errors(); + drop(default_early_dcx); interface::run_compiler(config, |compiler| { let sess = &compiler.sess; @@ -369,18 +369,18 @@ fn run_compiler( return sess.compile_status(); } - let handler = EarlyErrorHandler::new(sess.opts.error_format); + let early_dcx = EarlyDiagCtxt::new(sess.opts.error_format); - if print_crate_info(&handler, codegen_backend, sess, has_input) == Compilation::Stop { + if print_crate_info(&early_dcx, codegen_backend, sess, has_input) == Compilation::Stop { return sess.compile_status(); } if !has_input { - handler.early_error("no input filename given"); // this is fatal + early_dcx.early_error("no input filename given"); // this is fatal } if !sess.opts.unstable_opts.ls.is_empty() { - list_metadata(&handler, sess, &*codegen_backend.metadata_loader()); + list_metadata(&early_dcx, sess, &*codegen_backend.metadata_loader()); return sess.compile_status(); } @@ -495,7 +495,7 @@ fn make_output(matches: &getopts::Matches) -> (Option<PathBuf>, Option<OutFileNa // Extract input (string or file and optional path) from matches. fn make_input( - handler: &EarlyErrorHandler, + early_dcx: &EarlyDiagCtxt, free_matches: &[String], ) -> Result<Option<Input>, ErrorGuaranteed> { if free_matches.len() == 1 { @@ -505,7 +505,7 @@ fn make_input( if io::stdin().read_to_string(&mut src).is_err() { // Immediately stop compilation if there was an issue reading // the input (for example if the input stream is not UTF-8). - let reported = handler.early_error_no_abort( + let reported = early_dcx.early_error_no_abort( "couldn't read from stdin, as it did not contain valid UTF-8", ); return Err(reported); @@ -537,7 +537,7 @@ pub enum Compilation { Continue, } -fn handle_explain(handler: &EarlyErrorHandler, registry: Registry, code: &str, color: ColorConfig) { +fn handle_explain(early_dcx: &EarlyDiagCtxt, registry: Registry, code: &str, color: ColorConfig) { let upper_cased_code = code.to_ascii_uppercase(); let normalised = if upper_cased_code.starts_with('E') { upper_cased_code } else { format!("E{code:0>4}") }; @@ -567,7 +567,7 @@ fn handle_explain(handler: &EarlyErrorHandler, registry: Registry, code: &str, c } } Err(InvalidErrorCode) => { - handler.early_error(format!("{code} is not a valid error code")); + early_dcx.early_error(format!("{code} is not a valid error code")); } } } @@ -669,11 +669,7 @@ fn process_rlink(sess: &Session, compiler: &interface::Compiler) { } } -fn list_metadata( - handler: &EarlyErrorHandler, - sess: &Session, - metadata_loader: &dyn MetadataLoader, -) { +fn list_metadata(early_dcx: &EarlyDiagCtxt, sess: &Session, metadata_loader: &dyn MetadataLoader) { match sess.io.input { Input::File(ref ifile) => { let path = &(*ifile); @@ -689,13 +685,13 @@ fn list_metadata( safe_println!("{}", String::from_utf8(v).unwrap()); } Input::Str { .. } => { - handler.early_error("cannot list metadata for stdin"); + early_dcx.early_error("cannot list metadata for stdin"); } } } fn print_crate_info( - handler: &EarlyErrorHandler, + early_dcx: &EarlyDiagCtxt, codegen_backend: &dyn CodegenBackend, sess: &Session, parse_attrs: bool, @@ -842,7 +838,7 @@ fn print_crate_info( .expect("unknown Apple target OS"); println_info!("deployment_target={}", format!("{major}.{minor}")) } else { - handler + early_dcx .early_error("only Apple targets currently support deployment version info") } } @@ -856,12 +852,12 @@ fn print_crate_info( /// Prints version information /// /// NOTE: this is a macro to support drivers built at a different time than the main `rustc_driver` crate. -pub macro version($handler: expr, $binary: literal, $matches: expr) { +pub macro version($early_dcx: expr, $binary: literal, $matches: expr) { fn unw(x: Option<&str>) -> &str { x.unwrap_or("unknown") } $crate::version_at_macro_invocation( - $handler, + $early_dcx, $binary, $matches, unw(option_env!("CFG_VERSION")), @@ -873,7 +869,7 @@ pub macro version($handler: expr, $binary: literal, $matches: expr) { #[doc(hidden)] // use the macro instead pub fn version_at_macro_invocation( - handler: &EarlyErrorHandler, + early_dcx: &EarlyDiagCtxt, binary: &str, matches: &getopts::Matches, version: &str, @@ -894,7 +890,7 @@ pub fn version_at_macro_invocation( let debug_flags = matches.opt_strs("Z"); let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend=")); - get_codegen_backend(handler, &None, backend_name).print_version(); + get_codegen_backend(early_dcx, &None, backend_name).print_version(); } } @@ -1072,7 +1068,7 @@ Available lint options: /// Show help for flag categories shared between rustdoc and rustc. /// /// Returns whether a help option was printed. -pub fn describe_flag_categories(handler: &EarlyErrorHandler, matches: &Matches) -> bool { +pub fn describe_flag_categories(early_dcx: &EarlyDiagCtxt, matches: &Matches) -> bool { // Handle the special case of -Wall. let wall = matches.opt_strs("W"); if wall.iter().any(|x| *x == "all") { @@ -1094,12 +1090,12 @@ pub fn describe_flag_categories(handler: &EarlyErrorHandler, matches: &Matches) } if cg_flags.iter().any(|x| *x == "no-stack-check") { - handler.early_warn("the --no-stack-check flag is deprecated and does nothing"); + early_dcx.early_warn("the --no-stack-check flag is deprecated and does nothing"); } if cg_flags.iter().any(|x| *x == "passes=list") { let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend=")); - get_codegen_backend(handler, &None, backend_name).print_passes(); + get_codegen_backend(early_dcx, &None, backend_name).print_passes(); return true; } @@ -1160,7 +1156,7 @@ fn print_flag_list<T>( /// This does not need to be `pub` for rustc itself, but @chaosite needs it to /// be public when using rustc as a library, see /// <https://github.com/rust-lang/rust/commit/2b4c33817a5aaecabf4c6598d41e190080ec119e> -pub fn handle_options(handler: &EarlyErrorHandler, args: &[String]) -> Option<getopts::Matches> { +pub fn handle_options(early_dcx: &EarlyDiagCtxt, args: &[String]) -> Option<getopts::Matches> { if args.is_empty() { // user did not write `-v` nor `-Z unstable-options`, so do not // include that extra information. @@ -1186,7 +1182,7 @@ pub fn handle_options(handler: &EarlyErrorHandler, args: &[String]) -> Option<ge .map(|(flag, _)| format!("{e}. Did you mean `-{flag} {opt}`?")), _ => None, }; - handler.early_error(msg.unwrap_or_else(|| e.to_string())); + early_dcx.early_error(msg.unwrap_or_else(|| e.to_string())); }); // For all options we just parsed, we check a few aspects: @@ -1200,7 +1196,7 @@ pub fn handle_options(handler: &EarlyErrorHandler, args: &[String]) -> Option<ge // we're good to go. // * Otherwise, if we're an unstable option then we generate an error // (unstable option being used on stable) - nightly_options::check_nightly_options(handler, &matches, &config::rustc_optgroups()); + nightly_options::check_nightly_options(early_dcx, &matches, &config::rustc_optgroups()); if matches.opt_present("h") || matches.opt_present("help") { // Only show unstable options in --help if we accept unstable options. @@ -1210,12 +1206,12 @@ pub fn handle_options(handler: &EarlyErrorHandler, args: &[String]) -> Option<ge return None; } - if describe_flag_categories(handler, &matches) { + if describe_flag_categories(early_dcx, &matches) { return None; } if matches.opt_present("version") { - version!(handler, "rustc", &matches); + version!(early_dcx, "rustc", &matches); return None; } @@ -1310,7 +1306,10 @@ fn ice_path() -> &'static Option<PathBuf> { /// internal features. /// /// A custom rustc driver can skip calling this to set up a custom ICE hook. -pub fn install_ice_hook(bug_report_url: &'static str, extra_info: fn(&Handler)) -> Arc<AtomicBool> { +pub fn install_ice_hook( + bug_report_url: &'static str, + extra_info: fn(&DiagCtxt), +) -> Arc<AtomicBool> { // If the user has not explicitly overridden "RUST_BACKTRACE", then produce // full backtraces. When a compiler ICE happens, we want to gather // as much information as possible to present in the issue opened @@ -1333,8 +1332,8 @@ pub fn install_ice_hook(bug_report_url: &'static str, extra_info: fn(&Handler)) if msg.starts_with("failed printing to stdout: ") && msg.ends_with("(os error 232)") { // the error code is already going to be reported when the panic unwinds up the stack - let handler = EarlyErrorHandler::new(ErrorOutputType::default()); - let _ = handler.early_error_no_abort(msg.clone()); + let early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default()); + let _ = early_dcx.early_error_no_abort(msg.clone()); return; } }; @@ -1388,7 +1387,7 @@ pub fn install_ice_hook(bug_report_url: &'static str, extra_info: fn(&Handler)) fn report_ice( info: &panic::PanicInfo<'_>, bug_report_url: &str, - extra_info: fn(&Handler), + extra_info: fn(&DiagCtxt), using_internal_features: &AtomicBool, ) { let fallback_bundle = @@ -1397,20 +1396,20 @@ fn report_ice( rustc_errors::ColorConfig::Auto, fallback_bundle, )); - let handler = rustc_errors::Handler::with_emitter(emitter); + let dcx = rustc_errors::DiagCtxt::with_emitter(emitter); // a .span_bug or .bug call has already printed what // it wants to print. if !info.payload().is::<rustc_errors::ExplicitBug>() && !info.payload().is::<rustc_errors::DelayedBugPanic>() { - handler.emit_err(session_diagnostics::Ice); + dcx.emit_err(session_diagnostics::Ice); } if using_internal_features.load(std::sync::atomic::Ordering::Relaxed) { - handler.emit_note(session_diagnostics::IceBugReportInternalFeature); + dcx.emit_note(session_diagnostics::IceBugReportInternalFeature); } else { - handler.emit_note(session_diagnostics::IceBugReport { bug_report_url }); + dcx.emit_note(session_diagnostics::IceBugReport { bug_report_url }); } let version = util::version_str!().unwrap_or("unknown_version"); @@ -1422,7 +1421,7 @@ fn report_ice( // Create the ICE dump target file. match crate::fs::File::options().create(true).append(true).open(&path) { Ok(mut file) => { - handler.emit_note(session_diagnostics::IcePath { path: path.clone() }); + dcx.emit_note(session_diagnostics::IcePath { path: path.clone() }); if FIRST_PANIC.swap(false, Ordering::SeqCst) { let _ = write!(file, "\n\nrustc version: {version}\nplatform: {triple}"); } @@ -1430,26 +1429,26 @@ fn report_ice( } Err(err) => { // The path ICE couldn't be written to disk, provide feedback to the user as to why. - handler.emit_warning(session_diagnostics::IcePathError { + dcx.emit_warning(session_diagnostics::IcePathError { path: path.clone(), error: err.to_string(), env_var: std::env::var_os("RUSTC_ICE") .map(PathBuf::from) .map(|env_var| session_diagnostics::IcePathErrorEnv { env_var }), }); - handler.emit_note(session_diagnostics::IceVersion { version, triple }); + dcx.emit_note(session_diagnostics::IceVersion { version, triple }); None } } } else { - handler.emit_note(session_diagnostics::IceVersion { version, triple }); + dcx.emit_note(session_diagnostics::IceVersion { version, triple }); None }; if let Some((flags, excluded_cargo_defaults)) = rustc_session::utils::extra_compiler_flags() { - handler.emit_note(session_diagnostics::IceFlags { flags: flags.join(" ") }); + dcx.emit_note(session_diagnostics::IceFlags { flags: flags.join(" ") }); if excluded_cargo_defaults { - handler.emit_note(session_diagnostics::IceExcludeCargoDefaults); + dcx.emit_note(session_diagnostics::IceExcludeCargoDefaults); } } @@ -1458,11 +1457,11 @@ fn report_ice( let num_frames = if backtrace { None } else { Some(2) }; - interface::try_print_query_stack(&handler, num_frames, file); + interface::try_print_query_stack(&dcx, num_frames, file); // We don't trust this callback not to panic itself, so run it at the end after we're sure we've // printed all the relevant info. - extra_info(&handler); + extra_info(&dcx); #[cfg(windows)] if env::var("RUSTC_BREAK_ON_ICE").is_ok() { @@ -1473,16 +1472,16 @@ fn report_ice( /// This allows tools to enable rust logging without having to magically match rustc's /// tracing crate version. -pub fn init_rustc_env_logger(handler: &EarlyErrorHandler) { - init_logger(handler, rustc_log::LoggerConfig::from_env("RUSTC_LOG")); +pub fn init_rustc_env_logger(early_dcx: &EarlyDiagCtxt) { + init_logger(early_dcx, rustc_log::LoggerConfig::from_env("RUSTC_LOG")); } /// This allows tools to enable rust logging without having to magically match rustc's /// tracing crate version. In contrast to `init_rustc_env_logger` it allows you to choose /// the values directly rather than having to set an environment variable. -pub fn init_logger(handler: &EarlyErrorHandler, cfg: rustc_log::LoggerConfig) { +pub fn init_logger(early_dcx: &EarlyDiagCtxt, cfg: rustc_log::LoggerConfig) { if let Err(error) = rustc_log::init_logger(cfg) { - handler.early_error(error.to_string()); + early_dcx.early_error(error.to_string()); } } @@ -1490,9 +1489,9 @@ pub fn main() -> ! { let start_time = Instant::now(); let start_rss = get_resident_set_size(); - let handler = EarlyErrorHandler::new(ErrorOutputType::default()); + let early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default()); - init_rustc_env_logger(&handler); + init_rustc_env_logger(&early_dcx); signal_handler::install(); let mut callbacks = TimePassesCallbacks::default(); let using_internal_features = install_ice_hook(DEFAULT_BUG_REPORT_URL, |_| ()); @@ -1501,7 +1500,7 @@ pub fn main() -> ! { .enumerate() .map(|(i, arg)| { arg.into_string().unwrap_or_else(|arg| { - handler.early_error(format!("argument {i} is not valid Unicode: {arg:?}")) + early_dcx.early_error(format!("argument {i} is not valid Unicode: {arg:?}")) }) }) .collect::<Vec<_>>(); |