fix: Remove build-plan (#16212)

### What does this PR try to resolve?

Removes long-deprecated unstable functionality

Closes #5579, #7614, #7068, #6954, #5855

### How to test and review this PR?

Author: weihanglo

src/bin/cargo/commands/build.rs

@@ -35,7 +35,6 @@ pub fn cli() -> Command {
         .arg_target_triple("Build for the target triple")
         .arg_target_dir()
         .arg_artifact_dir()
-        .arg_build_plan()
         .arg_unit_graph()
         .arg_timings()
         .arg_compile_time_deps()

src/cargo/core/compiler/build_config.rs

@@ -27,8 +27,6 @@ pub struct BuildConfig {
     pub message_format: MessageFormat,
     /// Force Cargo to do a full rebuild and treat each target as changed.
     pub force_rebuild: bool,
-    /// Output a build plan to stdout instead of actually compiling.
-    pub build_plan: bool,
     /// Output the unit graph to stdout instead of actually compiling.
     pub unit_graph: bool,
     /// `true` to avoid really compiling.
@@ -123,7 +121,6 @@ impl BuildConfig {
             intent,
             message_format: MessageFormat::Human,
             force_rebuild: false,
-            build_plan: false,
             unit_graph: false,
             dry_run: false,
             primary_unit_rustc: None,

src/cargo/core/compiler/build_plan.rs

@@ -1,6 +1,6 @@
 //! [`BuildRunner`] is the mutable state used during the build process.
 
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
@@ -16,7 +16,6 @@ use filetime::FileTime;
 use itertools::Itertools;
 use jobserver::Client;
 
-use super::build_plan::BuildPlan;
 use super::custom_build::{self, BuildDeps, BuildScriptOutputs, BuildScripts};
 use super::fingerprint::{Checksum, Fingerprint};
 use super::job_queue::JobQueue;
@@ -168,8 +167,6 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
             .gctx
             .acquire_package_cache_lock(CacheLockMode::Shared)?;
         let mut queue = JobQueue::new(self.bcx);
-        let mut plan = BuildPlan::new();
-        let build_plan = self.bcx.build_config.build_plan;
         self.lto = super::lto::generate(self.bcx)?;
         self.prepare_units()?;
         self.prepare()?;
@@ -191,7 +188,7 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
 
         for unit in &self.bcx.roots {
             let force_rebuild = self.bcx.build_config.force_rebuild;
-            super::compile(&mut self, &mut queue, &mut plan, unit, exec, force_rebuild)?;
+            super::compile(&mut self, &mut queue, unit, exec, force_rebuild)?;
         }
 
         // Now that we've got the full job queue and we've done all our
@@ -205,12 +202,7 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
         }
 
         // Now that we've figured out everything that we're going to do, do it!
-        queue.execute(&mut self, &mut plan)?;
-
-        if build_plan {
-            plan.set_inputs(self.build_plan_inputs()?);
-            plan.output_plan(self.bcx.gctx);
-        }
+        queue.execute(&mut self)?;
 
         // Add `OUT_DIR` to env vars if unit has a build script.
         let units_with_build_script = &self
@@ -488,18 +480,6 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
         self.primary_packages.contains(&unit.pkg.package_id())
     }
 
-    /// Returns the list of filenames read by cargo to generate the [`BuildContext`]
-    /// (all `Cargo.toml`, etc.).
-    pub fn build_plan_inputs(&self) -> CargoResult<Vec<PathBuf>> {
-        // Keep sorted for consistency.
-        let mut inputs = BTreeSet::new();
-        // Note: dev-deps are skipped if they are not present in the unit graph.
-        for unit in self.bcx.unit_graph.keys() {
-            inputs.insert(unit.pkg.manifest_path().to_path_buf());
-        }
-        Ok(inputs.into_iter().collect())
-    }
-
     /// Returns a [`UnitOutput`] which represents some information about the
     /// output of a unit.
     pub fn unit_output(&self, unit: &Unit, path: &Path) -> UnitOutput {

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

@@ -35,7 +35,6 @@ use super::{BuildRunner, Job, Unit, Work, fingerprint, get_dynamic_search_path};
 use crate::core::compiler::CompileMode;
 use crate::core::compiler::artifact;
 use crate::core::compiler::build_runner::UnitHash;
-use crate::core::compiler::fingerprint::DirtyReason;
 use crate::core::compiler::job_queue::JobState;
 use crate::core::{PackageId, Target, profiles::ProfileRoot};
 use crate::util::errors::CargoResult;
@@ -340,8 +339,6 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
     let script_dir = build_runner.files().build_script_dir(build_script_unit);
     let script_out_dir = build_runner.files().build_script_out_dir(unit);
     let script_run_dir = build_runner.files().build_script_run_dir(unit);
-    let build_plan = bcx.build_config.build_plan;
-    let invocation_name = unit.buildkey();
 
     if let Some(deps) = unit.pkg.manifest().metabuild() {
         prepare_metabuild(build_runner, build_script_unit, deps)?;
@@ -527,7 +524,7 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
         // along to this custom build command. We're also careful to augment our
         // dynamic library search path in case the build script depended on any
         // native dynamic libraries.
-        if !build_plan {
+        {
             let build_script_outputs = build_script_outputs.lock().unwrap();
             for (name, dep_id, dep_metadata) in lib_deps {
                 let script_output = build_script_outputs.get(dep_metadata).ok_or_else(|| {
@@ -554,11 +551,6 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
             }
         }
 
-        if build_plan {
-            state.build_plan(invocation_name, cmd.clone(), Arc::new(Vec::new()));
-            return Ok(());
-        }
-
         // And now finally, run the build command itself!
         state.running(&cmd);
         let timestamp = paths::set_invocation_time(&script_run_dir)?;
@@ -706,11 +698,7 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
         Ok(())
     });
 
-    let mut job = if build_runner.bcx.build_config.build_plan {
-        Job::new_dirty(Work::noop(), DirtyReason::FreshBuild)
-    } else {
-        fingerprint::prepare_target(build_runner, unit, false)?
-    };
+    let mut job = fingerprint::prepare_target(build_runner, unit, false)?;
     if job.freshness().is_dirty() {
         job.before(dirty);
     } else {

src/cargo/core/compiler/custom_build.rs

@@ -5,7 +5,6 @@ use std::{cell::Cell, marker, sync::Arc};
 use cargo_util::ProcessBuilder;
 
 use crate::CargoResult;
-use crate::core::compiler::build_runner::OutputFile;
 use crate::core::compiler::future_incompat::FutureBreakageItem;
 use crate::core::compiler::timings::SectionTiming;
 use crate::util::Queue;
@@ -73,16 +72,6 @@ impl<'a, 'gctx> JobState<'a, 'gctx> {
         self.messages.push(Message::Run(self.id, cmd.to_string()));
     }
 
-    pub fn build_plan(
-        &self,
-        module_name: String,
-        cmd: ProcessBuilder,
-        filenames: Arc<Vec<OutputFile>>,
-    ) {
-        self.messages
-            .push(Message::BuildPlanMsg(module_name, cmd, filenames));
-    }
-
     pub fn stdout(&self, stdout: String) -> CargoResult<()> {
         if let Some(dedupe) = self.output {
             writeln!(dedupe.gctx.shell().out(), "{}", stdout)?;