refactor(target-info): Make a Workspace optional when loading the RustcTargetInfo

benches/benchsuite/benches/resolve.rs

@@ -25,7 +25,7 @@ struct ResolveInfo<'gctx> {
 fn do_resolve<'gctx>(gctx: &'gctx GlobalContext, ws_root: &Path) -> ResolveInfo<'gctx> {
     let requested_kinds = [CompileKind::Host];
     let ws = Workspace::new(&ws_root.join("Cargo.toml"), gctx).unwrap();
-    let mut target_data = RustcTargetData::new(&ws, &requested_kinds).unwrap();
+    let mut target_data = RustcTargetData::new(gctx, Some(&ws), &requested_kinds).unwrap();
     let cli_features = CliFeatures::from_command_line(&[], false, true).unwrap();
     let pkgs = cargo::ops::Packages::Default;
     let specs = pkgs.to_package_id_specs(&ws).unwrap();

src/compiler/build_context/target_info.rs

@@ -989,11 +989,11 @@ pub struct RustcTargetData<'gctx> {
 impl<'gctx> RustcTargetData<'gctx> {
     #[tracing::instrument(skip_all)]
     pub fn new(
-        ws: &Workspace<'gctx>,
+        gctx: &'gctx GlobalContext,
+        ws: Option<&Workspace<'gctx>>,
         requested_kinds: &[CompileKind],
     ) -> CargoResult<RustcTargetData<'gctx>> {
-        let gctx = ws.gctx();
-        let rustc = gctx.load_global_rustc(Some(ws))?;
+        let rustc = gctx.load_global_rustc(ws)?;
         let mut target_config = HashMap::default();
         let mut target_info = HashMap::default();
         let target_applies_to_host = gctx.target_applies_to_host()?;
@@ -1054,16 +1054,14 @@ impl<'gctx> RustcTargetData<'gctx> {
                 .iter()
                 .filter_map(|d| d.artifact()?.target()?.to_compile_kind())
         }
-        let all_kinds = requested_kinds
-            .iter()
-            .copied()
-            .chain(ws.members().flat_map(|p| {
-                p.manifest()
-                    .default_kind()
-                    .into_iter()
-                    .chain(p.manifest().forced_kind())
-                    .chain(artifact_targets(p))
-            }));
+        let members = ws.into_iter().flat_map(|ws| ws.members());
+        let all_kinds = requested_kinds.iter().copied().chain(members.flat_map(|p| {
+            p.manifest()
+                .default_kind()
+                .into_iter()
+                .chain(p.manifest().forced_kind())
+                .chain(artifact_targets(p))
+        }));
         for kind in all_kinds {
             res.merge_compile_kind(kind)?;
         }

src/ops/cargo_clean.rs

@@ -195,7 +195,7 @@ fn clean_specs(
 ) -> CargoResult<()> {
     // Clean specific packages.
     let requested_kinds = CompileKind::from_requested_targets(clean_ctx.gctx, targets)?;
-    let target_data = RustcTargetData::new(ws, &requested_kinds)?;
+    let target_data = RustcTargetData::new(ws.gctx(), Some(ws), &requested_kinds)?;
     let (pkg_set, resolve) = ops::resolve_ws(ws, dry_run)?;
     let prof_dir_name = profiles.get_dir_name();
     let host_layout = Layout::new(ws, None, &prof_dir_name, true, true)?;

src/ops/cargo_compile/mod.rs

@@ -294,7 +294,7 @@ pub fn create_bcx<'a, 'gctx>(
     }
     gctx.validate_term_config()?;
 
-    let mut target_data = RustcTargetData::new(ws, &build_config.requested_kinds)?;
+    let mut target_data = RustcTargetData::new(gctx, Some(ws), &build_config.requested_kinds)?;
 
     let specs = spec.to_package_id_specs(ws)?;
     let has_dev_units = {

src/ops/cargo_fetch.rs

@@ -34,7 +34,7 @@ pub fn fetch<'a>(
     let gctx = ws.gctx();
     let build_config =
         BuildConfig::new(gctx, jobs, keep_going, &options.targets, UserIntent::Build)?;
-    let mut data = RustcTargetData::new(ws, &build_config.requested_kinds)?;
+    let mut data = RustcTargetData::new(ws.gctx(), Some(ws), &build_config.requested_kinds)?;
     let mut fetched_packages = HashSet::default();
     let mut deps_to_fetch = ws.members().map(|p| p.package_id()).collect::<Vec<_>>();
     let mut to_download = Vec::new();

src/ops/cargo_fix/mod.rs

@@ -150,8 +150,11 @@ pub fn fix(
 ) -> CargoResult<()> {
     check_version_control(gctx, opts)?;
 
-    let mut target_data =
-        RustcTargetData::new(original_ws, &opts.compile_opts.build_config.requested_kinds)?;
+    let mut target_data = RustcTargetData::new(
+        gctx,
+        Some(original_ws),
+        &opts.compile_opts.build_config.requested_kinds,
+    )?;
 
     let specs = opts.compile_opts.spec.to_package_id_specs(&original_ws)?;
     let members: Vec<&Package> = original_ws

src/ops/cargo_metadata.rs

@@ -144,7 +144,7 @@ fn build_resolve_graph(
         &metadata_opts.filter_platforms,
         CompileKindFallback::JustHost,
     )?;
-    let mut target_data = RustcTargetData::new(ws, &requested_kinds)?;
+    let mut target_data = RustcTargetData::new(ws.gctx(), Some(ws), &requested_kinds)?;
     // Resolve entire workspace.
     let specs = Packages::All(Vec::new()).to_package_id_specs(ws)?;
     let force_all = if metadata_opts.filter_platforms.is_empty() {

src/ops/cargo_tree/mod.rs

@@ -148,7 +148,7 @@ pub fn build_and_print(ws: &Workspace<'_>, opts: &TreeOptions) -> CargoResult<()
     // TODO: Target::All is broken with -Zfeatures=itarget. To handle that properly,
     // `FeatureResolver` will need to be taught what "all" means.
     let requested_kinds = CompileKind::from_requested_targets(ws.gctx(), &requested_targets)?;
-    let mut target_data = RustcTargetData::new(ws, &requested_kinds)?;
+    let mut target_data = RustcTargetData::new(ws.gctx(), Some(ws), &requested_kinds)?;
     let specs = opts.packages.to_package_id_specs(ws)?;
     let has_dev = if opts
         .edge_kinds

src/util/command_prelude.rs

@@ -1416,7 +1416,7 @@ fn get_packages() -> CargoResult<Vec<Package>> {
     let ws = Workspace::new(&find_root_manifest_for_wd(gctx.cwd())?, &gctx)?;
 
     let requested_kinds = CompileKind::from_requested_targets(ws.gctx(), &[])?;
-    let mut target_data = RustcTargetData::new(&ws, &requested_kinds)?;
+    let mut target_data = RustcTargetData::new(&gctx, Some(&ws), &requested_kinds)?;
     // `cli_features.all_features` must be true in case that `specs` is empty.
     let cli_features = CliFeatures::new_all(true);
     let has_dev_units = HasDevUnits::Yes;