Introduce the concept of dependencies that should be stdlib-private

Dependencies of `std`, `core` and others are members of the crate graph,
but should not be available for access by the local crate or show up in
user-facing diagnostics. To support restricting this, introduce a
`stdlib_private_dep` field on `CrateMetadata` that  contains this
information.

Author: tgross35

compiler/rustc_metadata/src/creader.rs

@@ -29,7 +29,7 @@ use rustc_session::lint::{self, BuiltinLintDiag};
 use rustc_session::output::validate_crate_name;
 use rustc_session::search_paths::PathKind;
 use rustc_span::edition::Edition;
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Ident, STDLIB_STABLE_CRATES, Span, Symbol, sym};
 use rustc_target::spec::{PanicStrategy, Target, TargetTuple};
 use tracing::{debug, info, trace};
 
@@ -416,6 +416,10 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
         let private_dep = self.is_private_dep(name.as_str(), private_dep);
 
+        // At this point there are no other dependencies, so treat dependencies
+        // of `std` as stdlib-private.
+        let stdlib_private_dep = self.maybe_stdlib_private_dep(dep_root, name);
+
         // Claim this crate number and cache it
         let feed = self.cstore.intern_stable_crate_id(&crate_root, self.tcx)?;
         let cnum = feed.key();
@@ -465,6 +469,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             dep_kind,
             source,
             private_dep,
+            stdlib_private_dep,
             host_hash,
         );
 
@@ -533,6 +538,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }))
     }
 
+    /// Attempt to resolve the crate but emit an error if it fails.
     fn resolve_crate(
         &mut self,
         name: Symbol,
@@ -613,12 +619,19 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 // `private-dependency` when `register_crate` is called for the first time. Then it must be updated to
                 // `public-dependency` here.
                 let private_dep = self.is_private_dep(name.as_str(), private_dep);
+
+                // If the dependency root is something other than `std`, indicate that the crate
+                // should no longer be considered stdlib-private.
+                let maybe_stdlib_private = self.maybe_stdlib_private_dep(dep_root, name);
+
                 let data = self.cstore.get_crate_data_mut(cnum);
                 if data.is_proc_macro_crate() {
                     dep_kind = CrateDepKind::MacrosOnly;
                 }
                 data.set_dep_kind(cmp::max(data.dep_kind(), dep_kind));
                 data.update_and_private_dep(private_dep);
+                data.update_and_stdlib_private_dep(!maybe_stdlib_private);
+
                 Ok(cnum)
             }
             (LoadResult::Loaded(library), host_library) => {
@@ -1123,6 +1136,29 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     pub fn maybe_process_path_extern(&mut self, name: Symbol) -> Option<CrateNum> {
         self.maybe_resolve_crate(name, CrateDepKind::Explicit, None).ok()
     }
+
+    /// Return `true` if this is a crate is a dependency of the standard library, `false` otherwise.
+    ///
+    /// This function's result is not absolute, if the same dependency is used by a non-std crate
+    /// then it should not be treated as stdlib-private (hence the "maybe").
+    fn maybe_stdlib_private_dep(&self, dep_root: Option<&CratePaths>, new_crate: Symbol) -> bool {
+        // If there is no dependency root, this crate was passed directly.
+        let Some(dep_root) = dep_root else {
+            return false;
+        };
+
+        // If the new dependency is itself part of the stable stdlib crates (eg. `core` is a dep
+        // of `std`) or if the current crate is the standard library, stdlib-private is not
+        // relevant.
+        if STDLIB_STABLE_CRATES.contains(&new_crate)
+            || STDLIB_STABLE_CRATES.contains(&self.crate_name(LOCAL_CRATE))
+        {
+            return false;
+        }
+
+        // Otherwise, all crates that are a dependency of the standard library are private.
+        STDLIB_STABLE_CRATES.contains(&dep_root.name)
+    }
 }
 
 fn global_allocator_spans(krate: &ast::Crate) -> Vec<Span> {

compiler/rustc_metadata/src/locator.rs

@@ -262,7 +262,7 @@ pub(crate) struct CrateLocator<'a> {
 
 #[derive(Clone)]
 pub(crate) struct CratePaths {
-    name: Symbol,
+    pub(crate) name: Symbol,
     source: CrateSource,
 }
 

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -118,6 +118,9 @@ pub(crate) struct CrateMetadata {
     /// Used by the 'exported_private_dependencies' lint, and for determining
     /// whether to emit suggestions that reference this crate.
     private_dep: bool,
+    /// This crate is only used as a dependency of the standard library and by default should
+    /// not be user-facing (i.e. not shown in diagnostics).
+    stdlib_private_dep: bool,
     /// The hash for the host proc macro. Used to support `-Z dual-proc-macro`.
     host_hash: Option<Svh>,
     /// The crate was used non-speculatively.
@@ -1826,6 +1829,7 @@ impl CrateMetadata {
         dep_kind: CrateDepKind,
         source: CrateSource,
         private_dep: bool,
+        stdlib_private_dep: bool,
         host_hash: Option<Svh>,
     ) -> CrateMetadata {
         let trait_impls = root
@@ -1857,6 +1861,7 @@ impl CrateMetadata {
             dep_kind,
             source: Lrc::new(source),
             private_dep,
+            stdlib_private_dep,
             host_hash,
             used: false,
             extern_crate: None,
@@ -1908,6 +1913,10 @@ impl CrateMetadata {
         self.private_dep &= private_dep;
     }
 
+    pub(crate) fn update_and_stdlib_private_dep(&mut self, stdlib_private_dep: bool) {
+        self.stdlib_private_dep &= stdlib_private_dep;
+    }
+
     pub(crate) fn used(&self) -> bool {
         self.used
     }