Private dependencies in public interface lint rework

Cargo.lock

@@ -4669,7 +4669,6 @@ dependencies = [
  "rustc_middle",
  "rustc_span",
  "rustc_ty_walk",
- "tracing",
 ]
 
 [[package]]

compiler/rustc_ast_lowering/src/lib.rs

@@ -56,7 +56,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, ErrorGuaranteed};
 use rustc_hir::attrs::lang_items::LangItem;
 use rustc_hir::def::{DefKind, Namespace, PerNS, Res};
-use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId, LocalDefIdMap};
+use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalDefIdMap};
 use rustc_hir::definitions::PerParentDisambiguatorState;
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::{
@@ -178,6 +178,8 @@ struct PerOwnerLoweringState<'a, 'hir> {
     /// Collect items that were created by lowering the current owner.
     children: LocalDefIdMap<hir::MaybeOwner<'hir>>,
 
+    paths_from_private_deps: SortedMap<hir::ItemLocalId, CrateNum>,
+
     // -- Transient --
     impl_trait_defs: Vec<hir::GenericParam<'hir>>,
     impl_trait_bounds: Vec<hir::WherePredicate<'hir>>,
@@ -208,6 +210,7 @@ impl<'a, 'hir> PerOwnerLoweringState<'a, 'hir> {
             trait_map: Default::default(),
             delayed_lints: Vec::new(),
             children: LocalDefIdMap::default(),
+            paths_from_private_deps: Default::default(),
             impl_trait_defs: Vec::new(),
             impl_trait_bounds: Vec::new(),
         }
@@ -232,6 +235,7 @@ impl<'a, 'hir> PerOwnerLoweringState<'a, 'hir> {
         let trait_map = self.trait_map;
         let delayed_lints = Steal::new(self.delayed_lints.into_boxed_slice());
         let children = self.children;
+        let paths_from_private_deps = self.paths_from_private_deps;
 
         #[cfg(debug_assertions)]
         for (id, attrs) in attrs.iter() {
@@ -261,6 +265,8 @@ impl<'a, 'hir> PerOwnerLoweringState<'a, 'hir> {
                 parenting.stable_hash(&mut hcx, &mut stable_hasher);
                 trait_map.stable_hash(&mut hcx, &mut stable_hasher);
                 children.stable_hash(&mut hcx, &mut stable_hasher);
+                paths_from_private_deps.stable_hash(&mut hcx, &mut stable_hasher);
+
                 stable_hasher.finish()
             })
         });
@@ -273,6 +279,7 @@ impl<'a, 'hir> PerOwnerLoweringState<'a, 'hir> {
             trait_map,
             delayed_lints,
             children,
+            paths_from_private_deps,
         })
     }
 }
@@ -937,6 +944,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             .children
             .extend_unord(info.children.items().map(|(&def_id, &info)| (def_id, info)));
 
+        self.curr_owner.paths_from_private_deps.insert_presorted(
+            info.paths_from_private_deps.iter().map(|(key, value)| (key.clone(), value.clone())),
+        );
+
         debug_assert!(!self.curr_owner.children.contains_key(&owner_id.def_id));
         self.curr_owner.children.insert(owner_id.def_id, hir::MaybeOwner::Owner(info));
     }
@@ -964,6 +975,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             self.curr_owner.trait_map.insert(hir_id.local_id, *traits);
         }
 
+        if let Some(&krate) = self.curr_owner.owner.paths_from_private_deps.get(&ast_node_id) {
+            self.curr_owner.paths_from_private_deps.insert(hir_id.local_id, krate);
+        }
+
         // Check whether the same `NodeId` is lowered more than once.
         #[cfg(debug_assertions)]
         self.curr_owner.relowering_checker.assert_node_is_not_relowered(ast_node_id, local_id);

compiler/rustc_hir/src/hir.rs

@@ -34,7 +34,7 @@ use rustc_target::asm::InlineAsmRegOrRegClass;
 use tracing::debug;
 
 use crate::def::{CtorKind, DefKind, MacroKinds, PerNS, Res};
-use crate::def_id::{DefId, LocalDefIdMap};
+use crate::def_id::{CrateNum, DefId, LocalDefIdMap};
 use crate::intravisit::FnKind;
 use crate::lints::DelayedLints;
 
@@ -1388,6 +1388,9 @@ pub struct OwnerInfo<'hir> {
     pub trait_map: ItemLocalMap<&'hir [TraitCandidate<'hir>]>,
     /// Owners generated as side-effect by lowering.
     pub children: UnordMap<LocalDefId, MaybeOwner<'hir>>,
+    /// Map from each nested owner that is a type imported from a
+    /// private dependency; generated by resolve.
+    pub paths_from_private_deps: SortedMap<ItemLocalId, CrateNum>,
 
     /// Lints delayed during ast lowering to be emitted
     /// after hir has completely built

compiler/rustc_metadata/src/creader.rs

@@ -568,6 +568,10 @@ impl CStore {
         }
     }
 
+    fn is_extern_private_dep(&self, externs: &Externs, name: Symbol) -> bool {
+        externs.get(name.as_str()).map(|e| e.is_private_dep).unwrap_or_default()
+    }
+
     fn register_crate<'tcx>(
         &mut self,
         tcx: TyCtxt<'tcx>,
@@ -584,6 +588,7 @@ impl CStore {
         let Library { source, metadata } = lib;
         let crate_root = metadata.get_root();
         let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
+        let extern_private_dep = self.is_extern_private_dep(&tcx.sess.opts.externs, name);
         let private_dep = self.is_private_dep(&tcx.sess.opts.externs, name, private_dep);
 
         // Claim this crate number and cache it
@@ -642,6 +647,7 @@ impl CStore {
             dep_kind,
             source,
             private_dep,
+            extern_private_dep,
             host_hash,
         );
 

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -131,6 +131,10 @@ 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,
+    /// Whether or not this is explicitly marked as a private dependency, specifically whether
+    /// `--extern` contained `priv:`. This is not the same thing as `private_dep` as some
+    /// dependencies might be marked `priv:` but are public dependencies transitively.
+    extern_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.
@@ -779,14 +783,23 @@ impl MetadataBlob {
                     let dylib_dependency_formats =
                         root.dylib_dependency_formats.decode(self).collect::<Vec<_>>();
                     for (i, dep) in root.crate_deps.decode(self).enumerate() {
-                        let CrateDep { name, extra_filename, hash, host_hash, kind, is_private } =
-                            dep;
+                        let CrateDep {
+                            name,
+                            extra_filename,
+                            hash,
+                            host_hash,
+                            kind,
+                            is_private,
+                            is_extern_private_dep,
+                        } = dep;
                         let number = i + 1;
 
                         writeln!(
                             out,
-                            "{number} {name}{extra_filename} hash {hash} host_hash {host_hash:?} kind {kind:?} {privacy}{linkage}",
+                            "{number} {name}{extra_filename} hash {hash} host_hash {host_hash:?} kind {kind:?} {privacy}{direct_privacy}{linkage}",
                             privacy = if is_private { "private" } else { "public" },
+                            direct_privacy =
+                                if is_extern_private_dep { " extern:priv" } else { "" },
                             linkage = if dylib_dependency_formats.is_empty() {
                                 String::new()
                             } else {
@@ -1937,6 +1950,7 @@ impl CrateMetadata {
         dep_kind: CrateDepKind,
         source: CrateSource,
         private_dep: bool,
+        extern_private_dep: bool,
         host_hash: Option<Svh>,
     ) -> CrateMetadata {
         let trait_impls = root
@@ -1966,6 +1980,7 @@ impl CrateMetadata {
             dep_kind,
             source: Arc::new(source),
             private_dep,
+            extern_private_dep,
             host_hash,
             used: false,
             extern_crate: None,

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -334,6 +334,7 @@ provide! { tcx, def_id, other, cdata,
 
     dylib_dependency_formats => { cdata.get_dylib_dependency_formats(tcx) }
     is_private_dep => { cdata.private_dep }
+    is_extern_private_dep => { cdata.extern_private_dep }
     is_panic_runtime => { cdata.root.panic_runtime }
     is_compiler_builtins => { cdata.root.compiler_builtins }
 
@@ -439,6 +440,7 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
         allocator_kind: |tcx, ()| CStore::from_tcx(tcx).allocator_kind(),
         alloc_error_handler_kind: |tcx, ()| CStore::from_tcx(tcx).alloc_error_handler_kind(),
         is_private_dep: |_tcx, LocalCrate| false,
+        is_extern_private_dep: |_tcx, LocalCrate| false,
         native_library: |tcx, id| {
             tcx.native_libraries(id.krate)
                 .iter()

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -2112,6 +2112,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     kind: self.tcx.crate_dep_kind(cnum),
                     extra_filename: self.tcx.extra_filename(cnum).to_owned(),
                     is_private: self.tcx.is_private_dep(cnum),
+                    is_extern_private_dep: self.tcx.is_extern_private_dep(cnum),
                 };
                 (cnum, dep)
             })

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -340,6 +340,7 @@ pub(crate) struct CrateDep {
     pub kind: CrateDepKind,
     pub extra_filename: String,
     pub is_private: bool,
+    pub is_extern_private_dep: bool,
 }
 
 #[derive(MetadataEncodable, LazyDecodable)]

compiler/rustc_middle/src/hir/mod.rs

@@ -500,4 +500,6 @@ pub fn provide(providers: &mut Providers) {
         |tcx, trait_id| tcx.resolutions(()).trait_impls.get(&trait_id).map_or(&[], |xs| &xs[..]);
     providers.expn_that_defined =
         |tcx, id| tcx.resolutions(()).expn_that_defined.get(&id).copied().unwrap_or(ExpnId::root());
+    providers.paths_from_private_deps =
+        |tcx, id| tcx.lower_to_hir(id).as_owner().map(|owner| &owner.paths_from_private_deps);
 }

compiler/rustc_middle/src/middle/resolve.rs

@@ -213,6 +213,9 @@ pub struct PerOwnerResolverData<'tcx> {
     pub extra_lifetime_params_map: NodeMap<Vec<(Ident, NodeId, MissingLifetimeKind)>> =
         Default::default(),
 
+    /// Paths that use items exported or re-exported from a private dependency.
+    pub paths_from_private_deps: NodeMap<CrateNum> = Default::default(),
+
     /// The id of the owner
     pub id: NodeId,
     /// The `DefId` of the owner, can't be found in `node_id_to_def_id`.
@@ -253,6 +256,8 @@ pub struct ResolverAstLowering<'tcx> {
     /// Resolutions for nodes that have a single resolution.
     pub partial_res_map: NodeMap<PartialRes>,
 
+    pub paths_from_private_deps: NodeMap<CrateNum>,
+
     pub next_node_id: NodeId,
 
     pub owners: NodeMap<PerOwnerResolverData<'tcx>>,

compiler/rustc_middle/src/queries.rs

@@ -2388,6 +2388,16 @@ rustc_queries! {
         desc { "checking whether crate `{}` is a private dependency", c }
         separate_provide_extern
     }
+    /// Returns whether or not the crate with CrateNum 'cnum'
+    /// is marked as a direct public dependency
+    query is_extern_private_dep(c: CrateNum) -> bool {
+        eval_always
+        desc { "checking whether crate `{}` is a direct public dependency", c }
+        separate_provide_extern
+    }
+    query paths_from_private_deps(key: hir::OwnerId) -> Option<&'tcx SortedMap<hir::ItemLocalId, CrateNum>> {
+        desc { "getting paths imported from private dependencies in `{}`", tcx.def_path_str(key) }
+    }
     query allocator_kind(_: ()) -> Option<AllocatorKind> {
         eval_always
         desc { "getting the allocator kind for the current crate" }

compiler/rustc_middle/src/ty/context.rs

@@ -1272,6 +1272,10 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn is_method(self, id: DefId) -> bool {
         self.opt_associated_item(id).is_some_and(|item| item.is_method())
     }
+
+    pub fn path_pointing_to_private_crate(self, hir_id: HirId) -> Option<CrateNum> {
+        self.paths_from_private_deps(hir_id.owner)?.get(&hir_id.local_id).copied()
+    }
 }
 
 impl<'tcx> TyCtxtAt<'tcx> {

compiler/rustc_privacy/Cargo.toml

@@ -14,5 +14,4 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 rustc_ty_walk = { path = "../rustc_ty_walk" }
-tracing = "0.1"
 # tidy-alphabetical-end