Build-std: Add builtin dependencies

Cargo.toml

@@ -36,7 +36,7 @@ cargo-platform = { path = "crates/cargo-platform", version = "0.3.3" }
 cargo-test-macro = { version = "0.4.14", path = "crates/cargo-test-macro" }
 cargo-test-support = { version = "0.11.4", path = "crates/cargo-test-support" }
 cargo-util = { version = "0.2.32", path = "crates/cargo-util" }
-cargo-util-schemas = { version = "0.14.2", path = "crates/cargo-util-schemas" }
+cargo-util-schemas = { version = "0.15.0", path = "crates/cargo-util-schemas" }
 cargo-util-terminal = { version = "0.1.2", path = "crates/cargo-util-terminal" }
 cargo_metadata = "0.23.1"
 clap = "4.6.0"

crates/cargo-util-schemas/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cargo-util-schemas"
-version = "0.14.3"
+version = "0.15.0"
 rust-version = "1.97"  # MSRV:1
 edition.workspace = true
 license.workspace = true

crates/cargo-util-schemas/src/core/package_id_spec.rs

@@ -233,6 +233,11 @@ fn strip_url_protocol(url: &Url) -> Url {
 
 impl fmt::Display for PackageIdSpec {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.kind() == Some(&SourceKind::Builtin) {
+            // Builtins have a very specific pkgid output
+            write!(f, "builtin://.#{}", self.name)?;
+            return Ok(());
+        }
         let mut printed_name = false;
         match self.url {
             Some(ref url) => {

crates/cargo-util-schemas/src/core/source_kind.rs

@@ -15,6 +15,8 @@ pub enum SourceKind {
     LocalRegistry,
     /// A directory-based registry.
     Directory,
+    /// Package sources distributed with the rust toolchain
+    Builtin,
 }
 
 // The hash here is important for what folder packages get downloaded into.
@@ -40,6 +42,7 @@ impl SourceKind {
             SourceKind::SparseRegistry => None,
             SourceKind::LocalRegistry => Some("local-registry"),
             SourceKind::Directory => Some("directory"),
+            SourceKind::Builtin => Some("builtin"),
         }
     }
 }
@@ -71,6 +74,10 @@ impl Ord for SourceKind {
             (_, SourceKind::Directory) => Ordering::Greater,
 
             (SourceKind::Git(a), SourceKind::Git(b)) => a.cmp(b),
+            (SourceKind::Git(_), _) => Ordering::Less,
+            (_, SourceKind::Git(_)) => Ordering::Greater,
+
+            (SourceKind::Builtin, SourceKind::Builtin) => Ordering::Equal,
         }
     }
 }

crates/resolver-tests/src/helpers.rs

@@ -1,8 +1,12 @@
 use std::collections::BTreeMap;
 use std::fmt::Debug;
+use std::path::Path;
 use std::sync::OnceLock;
 
+use cargo::GlobalContext;
+use cargo::compiler::standard_lib::detect_sysroot_src_path;
 use cargo::util::IntoUrl;
+use cargo::util::data_structures::HashMap;
 use cargo::workspace::dependency::DepKind;
 use cargo::workspace::{Dependency, GitReference, PackageId, SourceId, Summary};
 
@@ -87,6 +91,29 @@ impl<T: AsRef<str>, U: AsRef<str>> ToPkgId for (T, U) {
     }
 }
 
+#[derive(Copy, Clone)]
+pub struct BuiltinPid {
+    pub name: &'static str,
+}
+
+impl ToPkgId for BuiltinPid {
+    fn to_pkgid(&self) -> PackageId {
+        PackageId::try_new(self.name, "0.0.0", builtin_loc()).unwrap()
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct BuiltinPidWithGctx<'a> {
+    pub name: &'static str,
+    pub gctx: &'a GlobalContext,
+}
+
+impl<'a> ToPkgId for BuiltinPidWithGctx<'a> {
+    fn to_pkgid(&self) -> PackageId {
+        PackageId::try_new(self.name, "0.0.0", builtin_loc_sysroot(self.gctx)).unwrap()
+    }
+}
+
 #[macro_export]
 macro_rules! pkg {
     ($pkgid:expr => [$($deps:expr),* $(,)? ]) => ({
@@ -108,6 +135,46 @@ fn registry_loc() -> SourceId {
     *example_dot
 }
 
+fn builtin_loc() -> SourceId {
+    static LOCAL_PATH: OnceLock<SourceId> = OnceLock::new();
+    let local_path = LOCAL_PATH.get_or_init(|| {
+        SourceId::for_builtin(Path::new(&std::env::current_dir().unwrap())).unwrap()
+    });
+    *local_path
+}
+
+fn builtin_loc_sysroot(gctx: &GlobalContext) -> SourceId {
+    static LOCAL_PATH: OnceLock<SourceId> = OnceLock::new();
+    let local_path = LOCAL_PATH.get_or_init(|| {
+        SourceId::for_builtin(&detect_sysroot_src_path(gctx, None).unwrap()).unwrap()
+    });
+    *local_path
+}
+
+pub fn gctx_for_build_std() -> GlobalContext {
+    let mut gctx = GlobalContext::default().unwrap();
+    gctx.nightly_features_allowed = true;
+    gctx.configure(
+        1,
+        false,
+        None,
+        false,
+        false,
+        false,
+        &None,
+        &["build-std=core".to_owned()],
+        &[],
+    )
+    .unwrap();
+    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/testsuite/mock-std/library");
+    let env = HashMap::from_iter([(
+        "__CARGO_TESTS_ONLY_SRC_ROOT".to_owned(),
+        root.into_os_string().into_string().unwrap(),
+    )]);
+    gctx.set_env(env);
+    gctx
+}
+
 pub fn pkg<T: ToPkgId>(name: T) -> Summary {
     pkg_dep(name, Vec::new())
 }
@@ -215,6 +282,10 @@ pub fn dep_loc(name: &str, location: &str) -> Dependency {
     Dependency::parse(name, Some("1.0.0"), source_id).unwrap()
 }
 
+pub fn dep_builtin(name: &str) -> Dependency {
+    Dependency::parse(name, None, builtin_loc()).unwrap()
+}
+
 pub fn dep_kind(name: &str, kind: DepKind) -> Dependency {
     let mut dep = dep(name);
     dep.set_kind(kind);
@@ -235,6 +306,12 @@ pub fn names<P: ToPkgId>(names: &[P]) -> Vec<PackageId> {
     names.iter().map(|name| name.to_pkgid()).collect()
 }
 
+/// For a set of name specifiers of varying types
+#[macro_export]
+macro_rules! names {
+    ($($name:expr),* $(,)?) => {&vec![$($name.to_pkgid()),*]};
+}
+
 pub fn loc_names(names: &[(&'static str, &'static str)]) -> Vec<PackageId> {
     names
         .iter()

crates/resolver-tests/src/lib.rs

@@ -57,11 +57,12 @@ pub fn resolve_and_validated_raw(
     root_pkg_id: PackageId,
     sat_resolver: &mut SatResolver,
 ) -> CargoResult<Vec<(PackageId, Vec<InternedString>)>> {
-    let resolve = resolve_with_global_context_raw(
+    let resolve = resolve_with_raw(
         deps.clone(),
         registry,
         root_pkg_id,
         &GlobalContext::default().unwrap(),
+        ResolveOpts::everything(),
     );
 
     match resolve {
@@ -120,15 +121,31 @@ pub fn resolve_with_global_context(
     registry: &[Summary],
     gctx: &GlobalContext,
 ) -> CargoResult<Vec<(PackageId, Vec<InternedString>)>> {
-    let resolve = resolve_with_global_context_raw(deps, registry, pkg_id("root"), gctx)?;
+    let resolve = resolve_with_raw(
+        deps,
+        registry,
+        pkg_id("root"),
+        gctx,
+        ResolveOpts::everything(),
+    )?;
     Ok(collect_features(&resolve))
 }
 
-pub fn resolve_with_global_context_raw(
+pub fn resolve_with_gctx_opts(
+    deps: Vec<Dependency>,
+    registry: &[Summary],
+    gctx: &GlobalContext,
+    opts: ResolveOpts,
+) -> CargoResult<Resolve> {
+    resolve_with_raw(deps, registry, pkg_id("root"), gctx, opts)
+}
+
+pub fn resolve_with_raw(
     deps: Vec<Dependency>,
     registry: &[Summary],
     root_pkg_id: PackageId,
     gctx: &GlobalContext,
+    opts: ResolveOpts,
 ) -> CargoResult<Resolve> {
     struct MyRegistry<'a> {
         list: &'a [Summary],
@@ -190,8 +207,6 @@ pub fn resolve_with_global_context_raw(
     let root_summary =
         Summary::new(root_pkg_id, deps, &BTreeMap::new(), None::<&String>, None).unwrap();
 
-    let opts = ResolveOpts::everything();
-
     let start = Instant::now();
     let mut version_prefs = VersionPreferences::default();
     if gctx.cli_unstable().minimal_versions {

crates/resolver-tests/tests/resolve.rs

@@ -1,15 +1,18 @@
+use cargo::resolver::ResolveOpts;
 use cargo::util::GlobalContext;
 use cargo::workspace::Dependency;
 use cargo::workspace::dependency::DepKind;
+use resolver_tests::helpers::gctx_for_build_std;
+use resolver_tests::helpers::{BuiltinPidWithGctx, dep_builtin};
 use snapbox::assert_data_eq;
 use snapbox::str;
 
 use resolver_tests::{
     helpers::{
-        ToDep, ToPkgId, assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req, loc_names,
-        names, pkg, pkg_dep, pkg_dep_with, pkg_id, pkg_loc, registry,
+        BuiltinPid, ToDep, ToPkgId, assert_contains, assert_same, dep, dep_kind, dep_loc, dep_req,
+        loc_names, names, pkg, pkg_dep, pkg_dep_with, pkg_id, pkg_loc, registry,
     },
-    pkg, resolve, resolve_with_global_context,
+    names, pkg, resolve, resolve_with_gctx_opts, resolve_with_global_context,
 };
 
 #[test]
@@ -1036,3 +1039,51 @@ failed to select a version for `F` which could resolve this conflict
 "#]]
     );
 }
+
+#[test]
+fn test_builtin_dependency() {
+    let core = BuiltinPid { name: "core" };
+    let reg = registry(vec![pkg!(core)]);
+
+    let res = resolve(vec![dep_builtin("core")], &reg).unwrap();
+
+    assert_same(&res, &names!("root", core));
+}
+
+#[test]
+fn normal_dependency_is_not_satisfied_by_builtin_package() {
+    let core = BuiltinPid { name: "core" };
+    let reg = registry(vec![pkg!(core)]);
+
+    assert!(resolve(vec![dep("core")], &reg).is_err());
+}
+
+#[test]
+fn missing_builtin_dependency_errors() {
+    assert!(resolve(vec![dep_builtin("core")], &registry(vec![])).is_err());
+}
+
+#[test]
+fn injects_builtins_when_required() {
+    let gctx = gctx_for_build_std();
+
+    let core = BuiltinPidWithGctx {
+        name: "core",
+        gctx: &gctx,
+    };
+    let compiler_builtins = BuiltinPidWithGctx {
+        name: "compiler_builtins",
+        gctx: &gctx,
+    };
+    let reg = registry(vec![pkg!(core), pkg!(compiler_builtins)]);
+
+    let mut opts = ResolveOpts::everything();
+    opts.inject_builtins = true;
+    let resolve = resolve_with_gctx_opts(Vec::new(), &reg, &gctx, opts).unwrap();
+
+    let root_deps = resolve
+        .deps(pkg_id("root"))
+        .map(|(pkg_id, _)| pkg_id)
+        .collect::<Vec<_>>();
+    assert_same(&root_deps, names!(core, compiler_builtins))
+}

src/compiler/build_context/target_info.rs

@@ -165,8 +165,6 @@ impl TargetInfo {
     /// invocation is cached by [`Rustc::cached_output`].
     ///
     /// Search `Tricky` to learn why querying `rustc` several times is needed.
-    ///
-    /// When a Workspace is provided,
     #[tracing::instrument(skip_all)]
     pub fn new(
         gctx: &GlobalContext,

src/compiler/standard_lib.rs

@@ -7,7 +7,7 @@ use crate::ops::{self, Packages};
 use crate::resolver::HasDevUnits;
 use crate::resolver::Resolve;
 use crate::resolver::features::{CliFeatures, FeaturesFor, ResolvedFeatures};
-use crate::util::errors::CargoResult;
+use crate::util::{CargoResult, GlobalContext};
 use crate::workspace::profiles::{Profiles, UnitFor};
 use crate::workspace::{PackageId, PackageSet, Workspace};
 
@@ -16,7 +16,11 @@ use std::path::PathBuf;
 
 use super::BuildConfig;
 
-fn std_crates<'a>(crates: &'a [String], default: &'static str, units: &[Unit]) -> HashSet<&'a str> {
+pub fn std_crates<'a>(
+    crates: &'a [String],
+    default: &'static str,
+    units: &[Unit],
+) -> HashSet<&'a str> {
     let mut crates = HashSet::from_iter(crates.iter().map(|s| s.as_str()));
     // This is a temporary hack until there is a more principled way to
     // declare dependencies in Cargo.toml.
@@ -54,12 +58,13 @@ pub fn resolve_std<'gctx>(
     crates: &[String],
     kinds: &[CompileKind],
 ) -> CargoResult<(PackageSet<'gctx>, Resolve, ResolvedFeatures)> {
-    let src_path = detect_sysroot_src_path(ws)?;
+    let src_path = detect_sysroot_src_path(ws.gctx(), Some(ws))?;
     let std_ws_manifest_path = src_path.join("Cargo.toml");
     let gctx = ws.gctx();
     // TODO: Consider doing something to enforce --locked? Or to prevent the
     // lock file from being written, such as setting ephemeral.
     let mut std_ws = Workspace::new(&std_ws_manifest_path, gctx)?;
+    std_ws.set_is_std(true);
     // Don't require optional dependencies in this workspace, aka std's own
     // `[dev-dependencies]`. No need for us to generate a `Resolve` which has
     // those included because we'll never use them anyway.
@@ -217,15 +222,17 @@ fn generate_roots(
     Ok(())
 }
 
-fn detect_sysroot_src_path(ws: &Workspace<'_>) -> CargoResult<PathBuf> {
-    if let Some(s) = ws.gctx().get_env_os("__CARGO_TESTS_ONLY_SRC_ROOT") {
+pub fn detect_sysroot_src_path(
+    gctx: &GlobalContext,
+    ws: Option<&Workspace<'_>>,
+) -> CargoResult<PathBuf> {
+    if let Some(s) = gctx.get_env_os("__CARGO_TESTS_ONLY_SRC_ROOT") {
         return Ok(s.into());
     }
 
     // NOTE: This is temporary until we figure out how to acquire the source.
-    let rustc = ws.gctx().load_global_rustc(Some(ws))?;
-    let src_path = ws
-        .gctx()
+    let rustc = gctx.load_global_rustc(ws)?;
+    let src_path = gctx
         .get_sysroot(&rustc)
         .expect("able to invoke rustc")
         .join("lib")
@@ -240,7 +247,7 @@ fn detect_sysroot_src_path(ws: &Workspace<'_>) -> CargoResult<PathBuf> {
              library, try:\n        rustup component add rust-src",
             lock
         );
-        match ws.gctx().get_env("RUSTUP_TOOLCHAIN") {
+        match gctx.get_env("RUSTUP_TOOLCHAIN") {
             Ok(rustup_toolchain) => {
                 anyhow::bail!("{} --toolchain {}", msg, rustup_toolchain);
             }