refactor: remove unsed Bench mode

The purpose of it was for indicating old "global mode".
There should be no difference between building a test or a bench,
as we already coerce Bench to Test:
https://github.com/rust-lang/cargo/blob/6ffc01f9fa7aa50d0/src/cargo/ops/cargo_compile/unit_generator.rs#L91-L99

The the removal of serialization for `CompileMode::Bench` affects
nothing because it was never really constructed.

Author: weihanglo

src/cargo/core/compiler/build_config.rs

@@ -175,11 +175,6 @@ pub enum CompileMode {
     /// If `test` is true, then it is also compiled with `--test` to check it like
     /// a test.
     Check { test: bool },
-    /// Used to indicate benchmarks should be built. This is not used in
-    /// `Unit`, because it is essentially the same as `Test` (indicating
-    /// `--test` should be passed to rustc) and by using `Test` instead it
-    /// allows some de-duping of Units to occur.
-    Bench,
     /// Document with `rustdoc`.
     ///
     /// If `deps` is true, then it will also document all dependencies.
@@ -203,7 +198,6 @@ impl ser::Serialize for CompileMode {
             Test => "test".serialize(s),
             Build => "build".serialize(s),
             Check { .. } => "check".serialize(s),
-            Bench => "bench".serialize(s),
             Doc { .. } => "doc".serialize(s),
             Doctest => "doctest".serialize(s),
             Docscrape => "docscrape".serialize(s),
@@ -238,19 +232,13 @@ impl CompileMode {
     pub fn is_any_test(self) -> bool {
         matches!(
             self,
-            CompileMode::Test
-                | CompileMode::Bench
-                | CompileMode::Check { test: true }
-                | CompileMode::Doctest
+            CompileMode::Test | CompileMode::Check { test: true } | CompileMode::Doctest
         )
     }
 
     /// Returns `true` if this is something that passes `--test` to rustc.
     pub fn is_rustc_test(self) -> bool {
-        matches!(
-            self,
-            CompileMode::Test | CompileMode::Bench | CompileMode::Check { test: true }
-        )
+        matches!(self, CompileMode::Test | CompileMode::Check { test: true })
     }
 
     /// Returns `true` if this is the *execution* of a `build.rs` script.
@@ -263,10 +251,7 @@ impl CompileMode {
     /// Note that this also returns `true` for building libraries, so you also
     /// have to check the target.
     pub fn generates_executable(self) -> bool {
-        matches!(
-            self,
-            CompileMode::Test | CompileMode::Bench | CompileMode::Build
-        )
+        matches!(self, CompileMode::Test | CompileMode::Build)
     }
 }
 

src/cargo/core/compiler/build_context/target_info.rs

@@ -574,7 +574,7 @@ impl TargetInfo {
     ) -> CargoResult<(Vec<FileType>, Vec<CrateType>)> {
         match mode {
             CompileMode::Build => self.calc_rustc_outputs(target_kind, target_triple, gctx),
-            CompileMode::Test | CompileMode::Bench => {
+            CompileMode::Test => {
                 match self.file_types(&CrateType::Bin, FileFlavor::Normal, target_triple)? {
                     Some(fts) => Ok((fts, Vec::new())),
                     None => Ok((Vec::new(), vec![CrateType::Bin])),

src/cargo/core/compiler/build_runner/compilation_files.rs

@@ -493,10 +493,7 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
                     flavor: FileFlavor::Normal,
                 }]
             }
-            CompileMode::Test
-            | CompileMode::Build
-            | CompileMode::Bench
-            | CompileMode::Check { .. } => {
+            CompileMode::Test | CompileMode::Build | CompileMode::Check { .. } => {
                 let mut outputs = self.calc_outputs_rustc(unit, bcx)?;
                 if bcx.build_config.sbom && bcx.gctx.cli_unstable().sbom {
                     let sbom_files: Vec<_> = outputs

src/cargo/core/compiler/lto.rs

@@ -97,7 +97,7 @@ fn calculate(
     let crate_types = match unit.mode {
         // Note: Doctest ignores LTO, but for now we'll compute it as-if it is
         // a Bin, in case it is ever supported in the future.
-        CompileMode::Test | CompileMode::Bench | CompileMode::Doctest => vec![CrateType::Bin],
+        CompileMode::Test | CompileMode::Doctest => vec![CrateType::Bin],
         // Notes on other modes:
         // - Check: Treat as the underlying type, it doesn't really matter.
         // - Doc: LTO is N/A for the Doc unit itself since rustdoc does not

src/cargo/core/compiler/timings.rs

@@ -168,7 +168,6 @@ impl<'gctx> Timings<'gctx> {
             CompileMode::Build => {}
             CompileMode::Check { test: true } => target.push_str(" (check-test)"),
             CompileMode::Check { test: false } => target.push_str(" (check)"),
-            CompileMode::Bench => target.push_str(" (bench)"),
             CompileMode::Doc { .. } => target.push_str(" (doc)"),
             CompileMode::Doctest => target.push_str(" (doc test)"),
             CompileMode::Docscrape => target.push_str(" (doc scrape)"),

src/cargo/ops/cargo_compile/unit_generator.rs

@@ -86,18 +86,9 @@ impl<'a> UnitGenerator<'a, '_> {
             }
             CompileMode::Build => match *target.kind() {
                 TargetKind::Test => CompileMode::Test,
-                TargetKind::Bench => CompileMode::Bench,
+                TargetKind::Bench => CompileMode::Test,
                 _ => CompileMode::Build,
             },
-            // `CompileMode::Bench` is only used to inform `filter_default_targets`
-            // which command is being used (`cargo bench`). Afterwards, tests
-            // and benches are treated identically. Switching the mode allows
-            // de-duplication of units that are essentially identical. For
-            // example, `cargo build --all-targets --release` creates the units
-            // (lib profile:bench, mode:test) and (lib profile:bench, mode:bench)
-            // and since these are the same, we want them to be de-duplicated in
-            // `unit_dependencies`.
-            CompileMode::Bench => CompileMode::Test,
             _ => initial_target_mode,
         };
 
@@ -476,11 +467,6 @@ impl<'a> UnitGenerator<'a, '_> {
                     FilterRule::All => Target::benched,
                     FilterRule::Just(_) => Target::is_bench,
                 };
-                let bench_mode = match self.intent {
-                    UserIntent::Build => CompileMode::Bench,
-                    UserIntent::Check { .. } => CompileMode::Check { test: true },
-                    _ => default_mode,
-                };
 
                 proposals.extend(self.list_rule_targets(
                     bins,
@@ -499,7 +485,7 @@ impl<'a> UnitGenerator<'a, '_> {
                     benches,
                     "bench",
                     bench_filter,
-                    bench_mode,
+                    test_mode,
                 )?);
             }
         }
@@ -792,8 +778,7 @@ Rustdoc did not scrape the following examples because they require dev-dependenc
 /// Converts [`UserIntent`] to [`CompileMode`] for root units.
 fn to_compile_mode(intent: UserIntent) -> CompileMode {
     match intent {
-        UserIntent::Test => CompileMode::Test,
-        UserIntent::Bench => CompileMode::Bench,
+        UserIntent::Test | UserIntent::Bench => CompileMode::Test,
         UserIntent::Build => CompileMode::Build,
         UserIntent::Check { test } => CompileMode::Check { test },
         UserIntent::Doc { deps, json } => CompileMode::Doc { deps, json },