Refactor argument UTF-8 checking into rustc_driver::args::raw_args()

Author: beetrees

compiler/rustc_driver_impl/src/args.rs

@@ -1,9 +1,5 @@
-use rustc_session::config::ErrorOutputType;
 use rustc_span::ErrorGuaranteed;
-use std::error;
-use std::fmt;
-use std::fs;
-use std::io;
+use std::{env, error, fmt, fs, io};
 
 use rustc_session::EarlyErrorHandler;
 
@@ -50,6 +46,29 @@ pub fn arg_expand_all(
     res
 }
 
+/// Gets the raw unprocessed command-line arguments as Unicode strings, without doing any further
+/// processing (e.g., without `@file` expansion).
+///
+/// This function is identical to [`env::args()`] except that it emits an error when it encounters
+/// non-Unicode arguments instead of panicking.
+pub fn raw_args(handler: &EarlyErrorHandler) -> Result<Vec<String>, ErrorGuaranteed> {
+    let mut res = Ok(Vec::new());
+    for (i, arg) in env::args_os().enumerate() {
+        match arg.into_string() {
+            Ok(arg) => {
+                if let Ok(args) = &mut res {
+                    args.push(arg);
+                }
+            }
+            Err(arg) => {
+                res = Err(handler
+                    .early_error_no_abort(format!("argument {i} is not valid Unicode: {arg:?}")))
+            }
+        }
+    }
+    res
+}
+
 #[derive(Debug)]
 enum Error {
     Utf8Error(String),

compiler/rustc_driver_impl/src/lib.rs

@@ -1565,17 +1565,8 @@ pub fn main() -> ! {
     signal_handler::install();
     let mut callbacks = TimePassesCallbacks::default();
     install_ice_hook(DEFAULT_BUG_REPORT_URL, |_| ());
-    let exit_code = catch_with_exit_code(|| {
-        let args = env::args_os()
-            .enumerate()
-            .map(|(i, arg)| {
-                arg.into_string().unwrap_or_else(|arg| {
-                    handler.early_error(format!("argument {i} is not valid Unicode: {arg:?}"))
-                })
-            })
-            .collect::<Vec<_>>();
-        RunCompiler::new(&args, &mut callbacks).run()
-    });
+    let exit_code =
+        catch_with_exit_code(|| RunCompiler::new(&args::raw_args(&handler)?, &mut callbacks).run());
 
     if let Some(format) = callbacks.time_passes {
         let end_rss = get_resident_set_size();

src/librustdoc/lib.rs

@@ -175,19 +175,15 @@ pub fn main() {
     init_logging(&handler);
     rustc_driver::init_env_logger(&handler, "RUSTDOC_LOG");
 
-    let exit_code = rustc_driver::catch_with_exit_code(|| match get_args(&handler) {
-        Some(args) => main_args(&mut handler, &args),
-        _ =>
-        {
-            #[allow(deprecated)]
-            Err(ErrorGuaranteed::unchecked_claim_error_was_emitted())
-        }
+    let exit_code = rustc_driver::catch_with_exit_code(|| {
+        let at_args = rustc_driver::args::raw_args(&handler)?;
+        main_args(&mut handler, &at_args)
     });
     process::exit(exit_code);
 }
 
 fn init_logging(handler: &EarlyErrorHandler) {
-    let color_logs = match std::env::var("RUSTDOC_LOG_COLOR").as_deref() {
+    let color_logs = match env::var("RUSTDOC_LOG_COLOR").as_deref() {
         Ok("always") => true,
         Ok("never") => false,
         Ok("auto") | Err(VarError::NotPresent) => io::stdout().is_terminal(),
@@ -217,19 +213,6 @@ fn init_logging(handler: &EarlyErrorHandler) {
     tracing::subscriber::set_global_default(subscriber).unwrap();
 }
 
-fn get_args(handler: &EarlyErrorHandler) -> Option<Vec<String>> {
-    env::args_os()
-        .enumerate()
-        .map(|(i, arg)| {
-            arg.into_string()
-                .map_err(|arg| {
-                    handler.early_warn(format!("Argument {i} is not valid Unicode: {arg:?}"));
-                })
-                .ok()
-        })
-        .collect()
-}
-
 fn opts() -> Vec<RustcOptGroup> {
     let stable: fn(_, fn(&mut getopts::Options) -> &mut _) -> _ = RustcOptGroup::stable;
     let unstable: fn(_, fn(&mut getopts::Options) -> &mut _) -> _ = RustcOptGroup::unstable;