rustc_codegen_ssa

Author: yotamofek

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -560,10 +560,10 @@ fn produce_final_output_artifacts(
     };
 
     let copy_if_one_unit = |output_type: OutputType, keep_numbered: bool| {
-        if compiled_modules.modules.len() == 1 {
+        if let [module] = &compiled_modules.modules[..] {
             // 1) Only one codegen unit. In this case it's no difficulty
             //    to copy `foo.0.x` to `foo.x`.
-            let module_name = Some(&compiled_modules.modules[0].name[..]);
+            let module_name = Some(&module.name[..]);
             let path = crate_output.temp_path(output_type, module_name);
             let output = crate_output.path(output_type);
             if !output_type.is_text_output() && output.is_tty() {
@@ -695,8 +695,8 @@ fn produce_final_output_artifacts(
     }
 
     if sess.opts.json_artifact_notifications {
-        if compiled_modules.modules.len() == 1 {
-            compiled_modules.modules[0].for_each_output(|_path, ty| {
+        if let [module] = &compiled_modules.modules[..] {
+            module.for_each_output(|_path, ty| {
                 if sess.opts.output_types.contains_key(&ty) {
                     let descr = ty.shorthand();
                     // for single cgu file is renamed to drop cgu specific suffix
@@ -852,7 +852,7 @@ pub(crate) fn compute_per_cgu_lto_type(
     // require LTO so the request for LTO is always unconditionally
     // passed down to the backend, but we don't actually want to do
     // anything about it yet until we've got a final product.
-    let is_rlib = sess_crate_types.len() == 1 && sess_crate_types[0] == CrateType::Rlib;
+    let is_rlib = matches!(sess_crate_types, [CrateType::Rlib]);
 
     match sess_lto {
         Lto::ThinLocal if !linker_does_lto && !is_allocator => ComputedLtoType::Thin,

compiler/rustc_errors/src/lib.rs

@@ -14,7 +14,9 @@
 #![feature(associated_type_defaults)]
 #![feature(box_into_inner)]
 #![feature(box_patterns)]
+#![feature(debug_closure_helpers)]
 #![feature(error_reporter)]
+#![feature(exact_size_is_empty)]
 #![feature(extract_if)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
@@ -35,6 +37,7 @@ use std::backtrace::{Backtrace, BacktraceStatus};
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::error::Report;
+use std::fmt::Write as _;
 use std::hash::Hash;
 use std::io::Write;
 use std::num::NonZero;
@@ -994,17 +997,17 @@ impl<'a> DiagCtxtHandle<'a> {
             count => Cow::from(format!("aborting due to {count} previous errors")),
         };
 
-        match (errors.len(), warnings.len()) {
-            (0, 0) => return,
-            (0, _) => {
+        match (errors.is_empty(), warnings.is_empty()) {
+            (true, true) => return,
+            (true, _) => {
                 // Use `ForceWarning` rather than `Warning` to guarantee emission, e.g. with a
                 // configuration like `--cap-lints allow --force-warn bare_trait_objects`.
                 inner.emit_diagnostic(
                     DiagInner::new(ForceWarning(None), DiagMessage::Str(warnings)),
                     None,
                 );
             }
-            (_, 0) => {
+            (_, true) => {
                 inner.emit_diagnostic(DiagInner::new(Error, errors), self.tainted_with_errors);
             }
             (_, _) => {
@@ -1029,28 +1032,32 @@ impl<'a> DiagCtxtHandle<'a> {
                     }
                 })
                 .collect::<Vec<_>>();
-            if !error_codes.is_empty() {
-                error_codes.sort();
-                if error_codes.len() > 1 {
-                    let limit = if error_codes.len() > 9 { 9 } else { error_codes.len() };
-                    let msg1 = format!(
-                        "Some errors have detailed explanations: {}{}",
-                        error_codes[..limit].join(", "),
-                        if error_codes.len() > 9 { "..." } else { "." }
+            error_codes.sort();
+            match &error_codes[..] {
+                [code] => {
+                    let msg = format!(
+                        "For more information about this error, try `rustc --explain {code}`.",
                     );
+                    inner.emit_diagnostic(DiagInner::new(FailureNote, msg), None);
+                }
+                [first_code, error_codes @ ..] => {
+                    let error_codes = fmt::from_fn(|f| {
+                        f.write_str(first_code)?;
+                        let mut error_codes = error_codes.iter();
+                        for code in error_codes.by_ref().take(8) {
+                            write!(f, ", {code}")?;
+                        }
+                        if error_codes.is_empty() { f.write_char('.') } else { f.write_str("...") }
+                    });
+                    // let limit = error_codes.len().max(9);
+                    let msg1 = format!("Some errors have detailed explanations: {error_codes}");
                     let msg2 = format!(
-                        "For more information about an error, try `rustc --explain {}`.",
-                        &error_codes[0]
+                        "For more information about an error, try `rustc --explain {first_code}`.",
                     );
                     inner.emit_diagnostic(DiagInner::new(FailureNote, msg1), None);
                     inner.emit_diagnostic(DiagInner::new(FailureNote, msg2), None);
-                } else {
-                    let msg = format!(
-                        "For more information about this error, try `rustc --explain {}`.",
-                        &error_codes[0]
-                    );
-                    inner.emit_diagnostic(DiagInner::new(FailureNote, msg), None);
                 }
+                _ => {}
             }
         }
     }