Rollup merge of #140077 - xizheyin:issue-139805, r=jieyouxu

Construct OutputType using macro and print [=FILENAME] help info

Closes #139805

Use define_output_types to define variants of OutputType, as well as refactor all of its methods for clarity. This way no variant is missed when pattern matching or output help messages.

On top of that, I optimized for `emit` help messages.

r? ```@jieyouxu```

compiler/rustc_session/src/config.rs

@@ -568,122 +568,203 @@ impl FromStr for SplitDwarfKind {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, HashStable_Generic)]
+macro_rules! define_output_types {
-#[derive(Encodable, Decodable)]
+    (
-pub enum OutputType {
+        $(
-    /// This is the optimized bitcode, which could be either pre-LTO or non-LTO bitcode,
+            $(#[doc = $doc:expr])*
-    /// depending on the specific request type.
+            $Variant:ident => {
-    Bitcode,
+                shorthand: $shorthand:expr,
-    /// This is the summary or index data part of the ThinLTO bitcode.
+                extension: $extension:expr,
-    ThinLinkBitcode,
+                description: $description:expr,
-    Assembly,
+                default_filename: $default_filename:expr,
-    LlvmAssembly,
+                is_text: $is_text:expr,
-    Mir,
+                compatible_with_cgus_and_single_output: $compatible:expr
-    Metadata,
+            }
-    Object,
+        ),* $(,)?
-    Exe,
+    ) => {
-    DepInfo,
+        #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, HashStable_Generic)]
-}
+        #[derive(Encodable, Decodable)]
+        pub enum OutputType {
+            $(
+                $(#[doc = $doc])*
+                $Variant,
+            )*
+        }
 
-impl StableOrd for OutputType {
+
+        impl StableOrd for OutputType {
             const CAN_USE_UNSTABLE_SORT: bool = true;
 
             // Trivial C-Style enums have a stable sort order across compilation sessions.
             const THIS_IMPLEMENTATION_HAS_BEEN_TRIPLE_CHECKED: () = ();
-}
+        }
 
-impl<HCX: HashStableContext> ToStableHashKey<HCX> for OutputType {
+        impl<HCX: HashStableContext> ToStableHashKey<HCX> for OutputType {
             type KeyType = Self;
 
             fn to_stable_hash_key(&self, _: &HCX) -> Self::KeyType {
                 *self
             }
-}
+        }
+
+
+        impl OutputType {
+            pub fn iter_all() -> impl Iterator<Item = OutputType> {
+                static ALL_VARIANTS: &[OutputType] = &[
+                    $(
+                        OutputType::$Variant,
+                    )*
+                ];
+                ALL_VARIANTS.iter().copied()
+            }
 
-impl OutputType {
             fn is_compatible_with_codegen_units_and_single_output_file(&self) -> bool {
                 match *self {
-            OutputType::Exe | OutputType::DepInfo | OutputType::Metadata => true,
+                    $(
-            OutputType::Bitcode
+                        OutputType::$Variant => $compatible,
-            | OutputType::ThinLinkBitcode
+                    )*
-            | OutputType::Assembly
-            | OutputType::LlvmAssembly
-            | OutputType::Mir
-            | OutputType::Object => false,
                 }
             }
 
             pub fn shorthand(&self) -> &'static str {
                 match *self {
-            OutputType::Bitcode => "llvm-bc",
+                    $(
-            OutputType::ThinLinkBitcode => "thin-link-bitcode",
+                        OutputType::$Variant => $shorthand,
-            OutputType::Assembly => "asm",
+                    )*
-            OutputType::LlvmAssembly => "llvm-ir",
-            OutputType::Mir => "mir",
-            OutputType::Object => "obj",
-            OutputType::Metadata => "metadata",
-            OutputType::Exe => "link",
-            OutputType::DepInfo => "dep-info",
                 }
             }
 
             fn from_shorthand(shorthand: &str) -> Option<Self> {
-        Some(match shorthand {
+                match shorthand {
-            "asm" => OutputType::Assembly,
+                    $(
-            "llvm-ir" => OutputType::LlvmAssembly,
+                        s if s == $shorthand => Some(OutputType::$Variant),
-            "mir" => OutputType::Mir,
+                    )*
-            "llvm-bc" => OutputType::Bitcode,
+                    _ => None,
-            "thin-link-bitcode" => OutputType::ThinLinkBitcode,
+                }
-            "obj" => OutputType::Object,
-            "metadata" => OutputType::Metadata,
-            "link" => OutputType::Exe,
-            "dep-info" => OutputType::DepInfo,
-            _ => return None,
-        })
             }
 
             fn shorthands_display() -> String {
-        format!(
+                let shorthands = vec![
-            "`{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`",
+                    $(
-            OutputType::Bitcode.shorthand(),
+                        format!("`{}`", $shorthand),
-            OutputType::ThinLinkBitcode.shorthand(),
+                    )*
-            OutputType::Assembly.shorthand(),
+                ];
-            OutputType::LlvmAssembly.shorthand(),
+                shorthands.join(", ")
-            OutputType::Mir.shorthand(),
-            OutputType::Object.shorthand(),
-            OutputType::Metadata.shorthand(),
-            OutputType::Exe.shorthand(),
-            OutputType::DepInfo.shorthand(),
-        )
             }
 
             pub fn extension(&self) -> &'static str {
                 match *self {
-            OutputType::Bitcode => "bc",
+                    $(
-            OutputType::ThinLinkBitcode => "indexing.o",
+                        OutputType::$Variant => $extension,
-            OutputType::Assembly => "s",
+                    )*
-            OutputType::LlvmAssembly => "ll",
-            OutputType::Mir => "mir",
-            OutputType::Object => "o",
-            OutputType::Metadata => "rmeta",
-            OutputType::DepInfo => "d",
-            OutputType::Exe => "",
                 }
             }
 
             pub fn is_text_output(&self) -> bool {
                 match *self {
-            OutputType::Assembly
+                    $(
-            | OutputType::LlvmAssembly
+                        OutputType::$Variant => $is_text,
-            | OutputType::Mir
+                    )*
-            | OutputType::DepInfo => true,
-            OutputType::Bitcode
-            | OutputType::ThinLinkBitcode
-            | OutputType::Object
-            | OutputType::Metadata
-            | OutputType::Exe => false,
                 }
             }
+
+            pub fn description(&self) -> &'static str {
+                match *self {
+                    $(
+                        OutputType::$Variant => $description,
+                    )*
+                }
+            }
+
+            pub fn default_filename(&self) -> &'static str {
+                match *self {
+                    $(
+                        OutputType::$Variant => $default_filename,
+                    )*
+                }
+            }
+
+
+        }
+    }
+}
+
+define_output_types! {
+    Assembly => {
+        shorthand: "asm",
+        extension: "s",
+        description: "Generates a file with the crate's assembly code",
+        default_filename: "CRATE_NAME.s",
+        is_text: true,
+        compatible_with_cgus_and_single_output: false
+    },
+    #[doc = "This is the optimized bitcode, which could be either pre-LTO or non-LTO bitcode,"]
+    #[doc = "depending on the specific request type."]
+    Bitcode => {
+        shorthand: "llvm-bc",
+        extension: "bc",
+        description: "Generates a binary file containing the LLVM bitcode",
+        default_filename: "CRATE_NAME.bc",
+        is_text: false,
+        compatible_with_cgus_and_single_output: false
+    },
+    DepInfo => {
+        shorthand: "dep-info",
+        extension: "d",
+        description: "Generates a file with Makefile syntax that indicates all the source files that were loaded to generate the crate",
+        default_filename: "CRATE_NAME.d",
+        is_text: true,
+        compatible_with_cgus_and_single_output: true
+    },
+    Exe => {
+        shorthand: "link",
+        extension: "",
+        description: "Generates the crates specified by --crate-type. This is the default if --emit is not specified",
+        default_filename: "(platform and crate-type dependent)",
+        is_text: false,
+        compatible_with_cgus_and_single_output: true
+    },
+    LlvmAssembly => {
+        shorthand: "llvm-ir",
+        extension: "ll",
+        description: "Generates a file containing LLVM IR",
+        default_filename: "CRATE_NAME.ll",
+        is_text: true,
+        compatible_with_cgus_and_single_output: false
+    },
+    Metadata => {
+        shorthand: "metadata",
+        extension: "rmeta",
+        description: "Generates a file containing metadata about the crate",
+        default_filename: "libCRATE_NAME.rmeta",
+        is_text: false,
+        compatible_with_cgus_and_single_output: true
+    },
+    Mir => {
+        shorthand: "mir",
+        extension: "mir",
+        description: "Generates a file containing rustc's mid-level intermediate representation",
+        default_filename: "CRATE_NAME.mir",
+        is_text: true,
+        compatible_with_cgus_and_single_output: false
+    },
+    Object => {
+        shorthand: "obj",
+        extension: "o",
+        description: "Generates a native object file",
+        default_filename: "CRATE_NAME.o",
+        is_text: false,
+        compatible_with_cgus_and_single_output: false
+    },
+    #[doc = "This is the summary or index data part of the ThinLTO bitcode."]
+    ThinLinkBitcode => {
+        shorthand: "thin-link-bitcode",
+        extension: "indexing.o",
+        description: "Generates the ThinLTO summary as bitcode",
+        default_filename: "CRATE_NAME.indexing.o",
+        is_text: false,
+        compatible_with_cgus_and_single_output: false
+    },
 }
 
 /// The type of diagnostics output to generate.
@@ -1570,6 +1651,18 @@ static PRINT_HELP: LazyLock<String> = LazyLock::new(|| {
     )
 });
 
+static EMIT_HELP: LazyLock<String> = LazyLock::new(|| {
+    let mut result =
+        String::from("Comma separated list of types of output for the compiler to emit.\n");
+    result.push_str("Each TYPE has the default FILE name:\n");
+
+    for output in OutputType::iter_all() {
+        result.push_str(&format!("*  {} - {}\n", output.shorthand(), output.default_filename()));
+    }
+
+    result
+});
+
 /// Returns all rustc command line options, including metadata for
 /// each option, such as whether the option is stable.
 pub fn rustc_optgroups() -> Vec<RustcOptGroup> {
@@ -1616,14 +1709,7 @@ pub fn rustc_optgroups() -> Vec<RustcOptGroup> {
         make_crate_type_option(),
         opt(Stable, Opt, "", "crate-name", "Specify the name of the crate being built", "NAME"),
         opt(Stable, Opt, "", "edition", &EDITION_STRING, EDITION_NAME_LIST),
-        opt(
+        opt(Stable, Multi, "", "emit", &EMIT_HELP, "TYPE[=FILE]"),
-            Stable,
-            Multi,
-            "",
-            "emit",
-            "Comma separated list of types of output for the compiler to emit",
-            "[asm|llvm-bc|llvm-ir|obj|metadata|link|dep-info|mir]",
-        ),
         opt(Stable, Multi, "", "print", &PRINT_HELP, "INFO[=FILE]"),
         opt(Stable, FlagMulti, "g", "", "Equivalent to -C debuginfo=2", ""),
         opt(Stable, FlagMulti, "O", "", "Equivalent to -C opt-level=3", ""),

tests/run-make/metadata-dep-info/dash-separated_something-extra.expected.d

@@ -1,5 +1,5 @@
-libdash_separated_something-extra.rmeta: dash-separated.rs
-
 dash-separated_something-extra.d: dash-separated.rs
 
+libdash_separated_something-extra.rmeta: dash-separated.rs
+
 dash-separated.rs:

tests/run-make/rustc-help/help-v.diff

@@ -1,4 +1,4 @@
-@@ -53,10 +53,27 @@
+@@ -63,10 +63,27 @@
                          Set a codegen option
      -V, --version       Print version info and exit
      -v, --verbose       Use verbose output

tests/run-make/rustc-help/help-v.stdout

@@ -26,9 +26,19 @@ Options:
                         Specify which edition of the compiler to use when
                         compiling code. The default is 2015 and the latest
                         stable edition is 2024.
-        --emit [asm|llvm-bc|llvm-ir|obj|metadata|link|dep-info|mir]
+        --emit TYPE[=FILE]
                         Comma separated list of types of output for the
-                        compiler to emit
+                        compiler to emit.
+                        Each TYPE has the default FILE name:
+                        * asm - CRATE_NAME.s
+                        * llvm-bc - CRATE_NAME.bc
+                        * dep-info - CRATE_NAME.d
+                        * link - (platform and crate-type dependent)
+                        * llvm-ir - CRATE_NAME.ll
+                        * metadata - libCRATE_NAME.rmeta
+                        * mir - CRATE_NAME.mir
+                        * obj - CRATE_NAME.o
+                        * thin-link-bitcode - CRATE_NAME.indexing.o
         --print INFO[=FILE]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of

tests/run-make/rustc-help/help.stdout

@@ -26,9 +26,19 @@ Options:
                         Specify which edition of the compiler to use when
                         compiling code. The default is 2015 and the latest
                         stable edition is 2024.
-        --emit [asm|llvm-bc|llvm-ir|obj|metadata|link|dep-info|mir]
+        --emit TYPE[=FILE]
                         Comma separated list of types of output for the
-                        compiler to emit
+                        compiler to emit.
+                        Each TYPE has the default FILE name:
+                        * asm - CRATE_NAME.s
+                        * llvm-bc - CRATE_NAME.bc
+                        * dep-info - CRATE_NAME.d
+                        * link - (platform and crate-type dependent)
+                        * llvm-ir - CRATE_NAME.ll
+                        * metadata - libCRATE_NAME.rmeta
+                        * mir - CRATE_NAME.mir
+                        * obj - CRATE_NAME.o
+                        * thin-link-bitcode - CRATE_NAME.indexing.o
         --print INFO[=FILE]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of

tests/ui/invalid-compile-flags/emit-output-types-without-args.rs

@@ -0,0 +1,2 @@
+//@ compile-flags: --emit
+//@ error-pattern: Argument to option 'emit' missing

tests/ui/invalid-compile-flags/emit-output-types-without-args.stderr

@@ -0,0 +1,15 @@
+error: Argument to option 'emit' missing
+       Usage:
+           --emit TYPE[=FILE]  Comma separated list of types of output for the
+                               compiler to emit.
+                               Each TYPE has the default FILE name:
+                               * asm - CRATE_NAME.s
+                               * llvm-bc - CRATE_NAME.bc
+                               * dep-info - CRATE_NAME.d
+                               * link - (platform and crate-type dependent)
+                               * llvm-ir - CRATE_NAME.ll
+                               * metadata - libCRATE_NAME.rmeta
+                               * mir - CRATE_NAME.mir
+                               * obj - CRATE_NAME.o
+                               * thin-link-bitcode - CRATE_NAME.indexing.o
+