Rename "target" to "unit" in code related to generate_targets

Author: willcrichton

src/cargo/ops/cargo_compile/compile_filter.rs

@@ -28,11 +28,11 @@ pub enum FilterRule {
 /// Filter to apply to the root package to select which Cargo targets will be built.
 /// (examples, bins, benches, tests, ...)
 ///
-/// The actual filter process happens inside [`generate_targets`].
+/// The actual filter process happens inside [`generate_units`].
 ///
 /// Not to be confused with [`Packages`], which opts in packages to be built.
 ///
-/// [`generate_targets`]: super::TargetGenerator::generate_targets
+/// [`generate_units`]: super::UnitGenerator::generate_units
 /// [`Packages`]: crate::ops::Packages
 #[derive(Debug)]
 pub enum CompileFilter {
@@ -176,7 +176,7 @@ impl CompileFilter {
     /// may include additional example targets to ensure they can be compiled.
     ///
     /// Note that the actual behavior is subject to `filter_default_targets`
-    /// and `generate_targets` though.
+    /// and `generate_units` though.
     pub fn all_test_targets() -> Self {
         Self::Only {
             all_targets: false,
@@ -234,7 +234,7 @@ impl CompileFilter {
     }
 
     /// Selects targets for "cargo run". for logic to select targets for other
-    /// subcommands, see `generate_targets` and `filter_default_targets`.
+    /// subcommands, see `generate_units` and `filter_default_targets`.
     pub fn target_run(&self, target: &Target) -> bool {
         match *self {
             CompileFilter::Default { .. } => true,

src/cargo/ops/cargo_compile/mod.rs

@@ -10,7 +10,7 @@
 //! - Download any packages needed (see [`PackageSet`](crate::core::PackageSet)).
 //! - Generate a list of top-level "units" of work for the targets the user
 //!   requested on the command-line. Each [`Unit`] corresponds to a compiler
-//!   invocation. This is done in this module ([`TargetGenerator::generate_targets`]).
+//!   invocation. This is done in this module ([`UnitGenerator::generate_units`]).
 //! - Build the graph of `Unit` dependencies (see [`unit_dependencies`]).
 //! - Create a [`Context`] which will perform the following steps:
 //!     - Prepare the `target` directory (see [`Layout`]).
@@ -54,9 +54,9 @@ use crate::util::{profile, CargoResult, StableHasher};
 mod compile_filter;
 pub use compile_filter::{CompileFilter, FilterRule, LibRule};
 
-mod target_generator;
-pub use target_generator::resolve_all_features;
-use target_generator::TargetGenerator;
+mod unit_generator;
+pub use unit_generator::resolve_all_features;
+use unit_generator::UnitGenerator;
 
 mod packages;
 
@@ -345,11 +345,11 @@ pub fn create_bcx<'a, 'cfg>(
         .collect();
 
     // Passing `build_config.requested_kinds` instead of
-    // `explicit_host_kinds` here so that `generate_targets` can do
+    // `explicit_host_kinds` here so that `generate_units` can do
     // its own special handling of `CompileKind::Host`. It will
     // internally replace the host kind by the `explicit_host_kind`
     // before setting as a unit.
-    let generator = TargetGenerator {
+    let generator = UnitGenerator {
         ws,
         packages: &to_builds,
         filter,
@@ -364,19 +364,19 @@ pub fn create_bcx<'a, 'cfg>(
         interner,
         has_dev_units,
     };
-    let mut units = generator.generate_targets()?;
+    let mut units = generator.generate_units()?;
 
     if let Some(args) = target_rustc_crate_types {
         override_rustc_crate_types(&mut units, args, interner)?;
     }
 
     let should_scrape = build_config.mode.is_doc() && config.cli_unstable().rustdoc_scrape_examples;
     let mut scrape_units = if should_scrape {
-        let scrape_generator = TargetGenerator {
+        let scrape_generator = UnitGenerator {
             mode: CompileMode::Docscrape,
             ..generator
         };
-        let all_units = scrape_generator.generate_targets()?;
+        let all_units = scrape_generator.generate_units()?;
 
         let valid_units = all_units
             .into_iter()

src/cargo/ops/cargo_compile/target_generator.rs renamed to src/cargo/ops/cargo_compile/unit_generator.rs

@@ -33,8 +33,8 @@ struct Proposal<'a> {
     mode: CompileMode,
 }
 
-/// The context needed for generating targets.
-pub(super) struct TargetGenerator<'a, 'cfg> {
+/// The context needed for generating units.
+pub(super) struct UnitGenerator<'a, 'cfg> {
     pub ws: &'a Workspace<'cfg>,
     pub packages: &'a [&'a Package],
     pub filter: &'a CompileFilter,
@@ -50,7 +50,7 @@ pub(super) struct TargetGenerator<'a, 'cfg> {
     pub has_dev_units: HasDevUnits,
 }
 
-impl<'a> TargetGenerator<'a, '_> {
+impl<'a> UnitGenerator<'a, '_> {
     /// Helper for creating a list of `Unit` structures
     fn new_units(
         &self,
@@ -657,9 +657,9 @@ impl<'a> TargetGenerator<'a, '_> {
         Ok(units)
     }
 
-    /// Generates all the base targets for the packages the user has requested to
-    /// compile. Dependencies for these targets are computed later in `unit_dependencies`.
-    pub fn generate_targets(&self) -> CargoResult<Vec<Unit>> {
+    /// Generates all the base units for the packages the user has requested to
+    /// compile. Dependencies for these units are computed later in `unit_dependencies`.
+    pub fn generate_units(&self) -> CargoResult<Vec<Unit>> {
         let proposals = self.create_proposals()?;
         self.proposals_to_units(proposals)
     }

src/doc/contrib/src/architecture/compilation.md

@@ -9,7 +9,7 @@ module. The compilation can be conceptually broken into these steps:
 
 1. Perform dependency resolution (see [the resolution chapter]).
 2. Generate the root `Unit`s, the things the user requested to compile on the
-   command-line. This is done in [`generate_targets`].
+   command-line. This is done in [`generate_units`].
 3. Starting from the root `Unit`s, generate the [`UnitGraph`] by walking the
    dependency graph from the resolver. The `UnitGraph` contains all of the
    `Unit` structs, and information about the dependency relationships between

src/doc/contrib/src/tests/writing.md

@@ -269,7 +269,7 @@ environment. The general process is:
    * `/path/to/my/cargo/target/debug/cargo check`
    * Using a debugger like `lldb` or `gdb`:
         1. `lldb /path/to/my/cargo/target/debug/cargo`
-        2. Set a breakpoint, for example: `b generate_targets`
+        2. Set a breakpoint, for example: `b generate_units`
         3. Run with arguments: `r check`
 
 [`testsuite`]: https://github.com/rust-lang/cargo/tree/master/tests/testsuite/