Better warning message for crate type unsupported by codegen backend

compiler/rustc_driver_impl/src/lib.rs

@@ -686,8 +686,12 @@ fn print_crate_info(
                 };
                 let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess);
                 let crate_name = passes::get_crate_name(sess, attrs);
-                let crate_types =
-                    collect_crate_types(sess, &codegen_backend.supported_crate_types(sess), attrs);
+                let crate_types = collect_crate_types(
+                    sess,
+                    &codegen_backend.supported_crate_types(sess),
+                    codegen_backend.name(),
+                    attrs,
+                );
                 for &style in &crate_types {
                     let fname = rustc_session::output::filename_for_input(
                         sess, style, crate_name, &t_outputs,

compiler/rustc_interface/src/passes.rs

@@ -929,6 +929,7 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
     let crate_types = collect_crate_types(
         sess,
         &compiler.codegen_backend.supported_crate_types(sess),
+        compiler.codegen_backend.name(),
         &pre_configured_attrs,
     );
     let stable_crate_id = StableCrateId::new(

compiler/rustc_session/messages.ftl

@@ -140,6 +140,9 @@ session_unleashed_feature_help_unnamed = skipping check that does not even have
 
 session_unstable_virtual_function_elimination = `-Zvirtual-function-elimination` requires `-Clto`
 
+session_unsupported_crate_type_for_codegen_backend =
+    dropping unsupported crate type `{$crate_type}` for codegen backend `{$codegen_backend}`
+
 session_unsupported_crate_type_for_target =
     dropping unsupported crate type `{$crate_type}` for target `{$target_triple}`
 

compiler/rustc_session/src/errors.rs

@@ -371,6 +371,13 @@ struct BinaryFloatLiteralNotSupported {
     span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(session_unsupported_crate_type_for_codegen_backend)]
+pub(crate) struct UnsupportedCrateTypeForCodegenBackend {
+    pub(crate) crate_type: CrateType,
+    pub(crate) codegen_backend: &'static str,
+}
+
 #[derive(Diagnostic)]
 #[diag(session_unsupported_crate_type_for_target)]
 pub(crate) struct UnsupportedCrateTypeForTarget<'a> {

compiler/rustc_session/src/output.rs

@@ -177,6 +177,7 @@ pub fn categorize_crate_type(s: Symbol) -> Option<CrateType> {
 pub fn collect_crate_types(
     session: &Session,
     backend_crate_types: &[CrateType],
+    codegen_backend_name: &'static str,
     attrs: &[ast::Attribute],
 ) -> Vec<CrateType> {
     // If we're generating a test executable, then ignore all other output
@@ -223,17 +224,18 @@ pub fn collect_crate_types(
     }
 
     base.retain(|crate_type| {
-        if invalid_output_for_target(session, *crate_type)
-            || !backend_crate_types.contains(crate_type)
-        {
-            // FIXME provide a better warning for the case where the codegen
-            // backend doesn't support it once cargo doesn't hard code this
-            // warning message.
+        if invalid_output_for_target(session, *crate_type) {
             session.dcx().emit_warn(errors::UnsupportedCrateTypeForTarget {
                 crate_type: *crate_type,
                 target_triple: &session.opts.target_triple,
             });
             false
+        } else if !backend_crate_types.contains(crate_type) {
+            session.dcx().emit_warn(errors::UnsupportedCrateTypeForCodegenBackend {
+                crate_type: *crate_type,
+                codegen_backend: codegen_backend_name,
+            });
+            false
         } else {
             true
         }