Add tcx.visible_traits() and use it for producing diagnostics

Add an alternative to `tcx.all_traits()` that only shows traits that the
user might be able to use, for diagnostic purposes. With this available,
make use of it for diagnostics including associated type errors which
fixes [1].

Includes a few comment updates for related API.

Fixes: #135232 [1]

Author: tgross35

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -179,7 +179,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // all visible traits. If there's one clear winner, just suggest that.
 
         let visible_traits: Vec<_> = tcx
-            .all_traits()
+            .visible_traits()
             .filter(|trait_def_id| {
                 let viz = tcx.visibility(*trait_def_id);
                 let def_id = self.item_def_id();

compiler/rustc_metadata/src/creader.rs

@@ -390,10 +390,12 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         None
     }
 
-    // The `dependency` type is determined by the command line arguments(`--extern`) and
-    // `private_dep`. However, sometimes the directly dependent crate is not specified by
-    // `--extern`, in this case, `private-dep` is none during loading. This is equivalent to the
-    // scenario where the command parameter is set to `public-dependency`
+    /// The `dependency` type is determined by the command line arguments(`--extern`) and
+    /// `private_dep`.
+    ///
+    /// Sometimes the directly dependent crate is not specified by `--extern`, in this case,
+    /// `private-dep` is none during loading. This is equivalent to the scenario where the
+    /// command parameter is set to `public-dependency`
     fn is_private_dep(&self, name: &str, private_dep: Option<bool>) -> bool {
         self.sess.opts.externs.get(name).map_or(private_dep.unwrap_or(false), |e| e.is_private_dep)
             && private_dep.unwrap_or(true)

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_middle/src/query/mod.rs

@@ -2128,6 +2128,8 @@ rustc_queries! {
         eval_always
         desc { "calculating the stability index for the local crate" }
     }
+    /// All available crates in the graph, including those that should not be user-facing
+    /// (such as private crates).
     query crates(_: ()) -> &'tcx [CrateNum] {
         eval_always
         desc { "fetching all foreign CrateNum instances" }

compiler/rustc_middle/src/ty/context.rs

@@ -2078,12 +2078,23 @@ impl<'tcx> TyCtxt<'tcx> {
         self.limits(()).move_size_limit
     }
 
+    /// All traits in the crate graph, including those not visible to the user.
     pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
         iter::once(LOCAL_CRATE)
             .chain(self.crates(()).iter().copied())
             .flat_map(move |cnum| self.traits(cnum).iter().copied())
     }
 
+    /// All traits that are visible within the crate graph (i.e. excluding private dependencies).
+    pub fn visible_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
+        let visible_crates =
+            self.crates(()).iter().copied().filter(move |cnum| self.is_user_visible_dep(*cnum));
+
+        iter::once(LOCAL_CRATE)
+            .chain(visible_crates)
+            .flat_map(move |cnum| self.traits(cnum).iter().copied())
+    }
+
     #[inline]
     pub fn local_visibility(self, def_id: LocalDefId) -> Visibility {
         self.visibility(def_id).expect_local()

compiler/rustc_passes/src/diagnostic_items.rs

@@ -79,8 +79,14 @@ fn all_diagnostic_items(tcx: TyCtxt<'_>, (): ()) -> DiagnosticItems {
     // Initialize the collector.
     let mut items = DiagnosticItems::default();
 
-    // Collect diagnostic items in other crates.
-    for &cnum in tcx.crates(()).iter().chain(std::iter::once(&LOCAL_CRATE)) {
+    // Collect diagnostic items in visible crates.
+    for cnum in tcx
+        .crates(())
+        .iter()
+        .copied()
+        .filter(|cnum| tcx.is_user_visible_dep(*cnum))
+        .chain(std::iter::once(LOCAL_CRATE))
+    {
         for (&name, &def_id) in &tcx.diagnostic_items(cnum).name_to_id {
             collect_item(tcx, &mut items, name, def_id);
         }

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -2189,7 +2189,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let required_trait_path = self.tcx.def_path_str(trait_ref.def_id());
         let traits_with_same_path: UnordSet<_> = self
             .tcx
-            .all_traits()
+            .visible_traits()
             .filter(|trait_def_id| *trait_def_id != trait_ref.def_id())
             .map(|trait_def_id| (self.tcx.def_path_str(trait_def_id), trait_def_id))
             .filter(|(p, _)| *p == required_trait_path)

tests/ui/std/sysroot-private.default.stderr

@@ -1,11 +1,11 @@
 error[E0405]: cannot find trait `Equivalent` in this scope
-  --> $DIR/sysroot-private.rs:24:18
+  --> $DIR/sysroot-private.rs:25:18
    |
 LL | trait Trait2<K>: Equivalent<K> {}
    |                  ^^^^^^^^^^ not found in this scope
 
 error[E0412]: cannot find type `K` in this scope
-  --> $DIR/sysroot-private.rs:29:35
+  --> $DIR/sysroot-private.rs:30:35
    |
 LL | fn trait_member<T>(val: &T, key: &K) -> bool {
    |                 -                 ^
@@ -22,13 +22,13 @@ LL | fn trait_member<T, K>(val: &T, key: &K) -> bool {
    |                  +++
 
 error[E0220]: associated type `Buf` not found for `Trait`
-  --> $DIR/sysroot-private.rs:19:31
+  --> $DIR/sysroot-private.rs:20:31
    |
 LL | type AssociatedTy = dyn Trait<Buf = i32, Bar = i32>;
-   |                               ^^^ there is an associated type `Buf` in the trait `addr2line::lookup::LookupContinuation`
+   |                               ^^^ help: `Trait` has the following associated type: `Bar`
 
 error[E0425]: cannot find function `memchr2` in this scope
-  --> $DIR/sysroot-private.rs:37:5
+  --> $DIR/sysroot-private.rs:38:5
    |
 LL |     memchr2(b'a', b'b', buf)
    |     ^^^^^^^ not found in this scope

tests/ui/std/sysroot-private.rs

@@ -16,9 +16,10 @@
 trait Trait { type Bar; }
 
 // Attempt to get a suggestion for `addr2line::LookupContinuation`, which has member `Buf`
+// Note that the suggestion only happens when `rustc_private` is enabled.
 type AssociatedTy = dyn Trait<Buf = i32, Bar = i32>;
 //~^ ERROR associated type `Buf` not found
-//~| NOTE there is an associated type `Buf` in the trait `addr2line::lookup::LookupContinuation`
+//[rustc_private_enabled]~| NOTE there is an associated type `Buf` in the trait `addr2line::lookup::LookupContinuation`
 
 // Attempt to get a suggestion for `hashbrown::Equivalent`
 trait Trait2<K>: Equivalent<K> {}

tests/ui/std/sysroot-private.rustc_private_enabled.stderr

@@ -1,11 +1,11 @@
 error[E0405]: cannot find trait `Equivalent` in this scope
-  --> $DIR/sysroot-private.rs:24:18
+  --> $DIR/sysroot-private.rs:25:18
    |
 LL | trait Trait2<K>: Equivalent<K> {}
    |                  ^^^^^^^^^^ not found in this scope
 
 error[E0412]: cannot find type `K` in this scope
-  --> $DIR/sysroot-private.rs:29:35
+  --> $DIR/sysroot-private.rs:30:35
    |
 LL | fn trait_member<T>(val: &T, key: &K) -> bool {
    |                 -                 ^
@@ -22,13 +22,13 @@ LL | fn trait_member<T, K>(val: &T, key: &K) -> bool {
    |                  +++
 
 error[E0220]: associated type `Buf` not found for `Trait`
-  --> $DIR/sysroot-private.rs:19:31
+  --> $DIR/sysroot-private.rs:20:31
    |
 LL | type AssociatedTy = dyn Trait<Buf = i32, Bar = i32>;
    |                               ^^^ there is an associated type `Buf` in the trait `addr2line::lookup::LookupContinuation`
 
 error[E0425]: cannot find function `memchr2` in this scope
-  --> $DIR/sysroot-private.rs:37:5
+  --> $DIR/sysroot-private.rs:38:5
    |
 LL |     memchr2(b'a', b'b', buf)
    |     ^^^^^^^ not found in this scope