rustdoc-json: discard non-local inherent impls

Author: its-the-shrimp

src/librustdoc/formats/cache.rs

@@ -442,16 +442,16 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
                     // `public_items` map, so we can skip inserting into the
                     // paths map if there was already an entry present and we're
                     // not a public item.
-                    if !self.cache.paths.contains_key(&item.item_id.expect_def_id())
+                    let item_def_id = item.item_id.expect_def_id();
+                    if !self.cache.paths.contains_key(&item_def_id)
                         || self
                             .cache
                             .effective_visibilities
-                            .is_directly_public(self.tcx, item.item_id.expect_def_id())
+                            .is_directly_public(self.tcx, item_def_id)
                     {
-                        self.cache.paths.insert(
-                            item.item_id.expect_def_id(),
-                            (self.cache.stack.clone(), item.type_()),
-                        );
+                        self.cache
+                            .paths
+                            .insert(item_def_id, (self.cache.stack.clone(), item.type_()));
                     }
                 }
             }
@@ -543,19 +543,23 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
                 }
             }
             let impl_item = Impl { impl_item: item };
-            if impl_item.trait_did().map_or(true, |d| self.cache.traits.contains_key(&d)) {
+            let impl_def_id = impl_item.def_id();
+            let impl_trait_id = impl_item.trait_did();
+            if match impl_trait_id {
+                Some(d) => self.cache.traits.contains_key(&d),
+                None => impl_def_id.is_local() || impl_item.is_on_local_type(self.cache, self.tcx),
+            } {
                 for did in dids {
-                    if self.impl_ids.entry(did).or_default().insert(impl_item.def_id()) {
+                    if self.impl_ids.entry(did).or_default().insert(impl_def_id) {
                         self.cache
                             .impls
                             .entry(did)
                             .or_insert_with(Vec::new)
                             .push(impl_item.clone());
                     }
                 }
-            } else {
-                let trait_did = impl_item.trait_did().expect("no trait did");
-                self.cache.orphan_trait_impls.push((trait_did, dids, impl_item));
+            } else if let Some(impl_trait_id) = impl_trait_id {
+                self.cache.orphan_trait_impls.push((impl_trait_id, dids, impl_item));
             }
             None
         } else {

src/librustdoc/formats/mod.rs

@@ -2,11 +2,12 @@ pub(crate) mod cache;
 pub(crate) mod item_type;
 pub(crate) mod renderer;
 
+use cache::Cache;
 pub(crate) use renderer::{run_format, FormatRenderer};
 use rustc_hir::def_id::DefId;
+use rustc_middle::ty::TyCtxt;
 
 use crate::clean::{self, ItemId};
-use crate::html::render::Context;
 
 /// Metadata about implementations for a type or trait.
 #[derive(Clone, Debug)]
@@ -43,8 +44,7 @@ impl Impl {
     // Returns true if this is an implementation on a "local" type, meaning:
     // the type is in the current crate, or the type and the trait are both
     // re-exported by the current crate.
-    pub(crate) fn is_on_local_type(&self, cx: &Context<'_>) -> bool {
-        let cache = cx.cache();
+    pub(crate) fn is_on_local_type(&self, cache: &Cache, tcx: TyCtxt<'_>) -> bool {
         let for_type = &self.inner_impl().for_;
         if let Some(for_type_did) = for_type.def_id(cache) {
             // The "for" type is local if it's in the paths for the current crate.
@@ -67,7 +67,7 @@ impl Impl {
                 // a foreign type. To make sure that confusion doesn't pass on to
                 // the reader, consider all implementations in std, core, and alloc
                 // to be on local types.
-                let crate_name = cx.tcx().crate_name(trait_did.krate);
+                let crate_name = tcx.crate_name(trait_did.krate);
                 if matches!(crate_name.as_str(), "std" | "core" | "alloc") {
                     return true;
                 }

src/librustdoc/html/render/print_item.rs

@@ -980,8 +980,9 @@ fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean:
             }
         }
 
-        let (local, mut foreign) =
-            implementors.iter().partition::<Vec<_>, _>(|i| i.is_on_local_type(cx));
+        let (local, mut foreign) = implementors
+            .iter()
+            .partition::<Vec<_>, _>(|i| i.is_on_local_type(cx.cache(), cx.tcx()));
 
         let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
             local.iter().partition(|i| i.inner_impl().kind.is_auto());

src/librustdoc/html/render/sidebar.rs

@@ -199,7 +199,7 @@ fn sidebar_trait<'a>(
         foreign_impls.extend(
             implementors
                 .iter()
-                .filter(|i| !i.is_on_local_type(cx))
+                .filter(|i| !i.is_on_local_type(cx.cache(), cx.tcx()))
                 .filter_map(|i| super::extract_for_impl_name(&i.impl_item, cx))
                 .map(|(name, id)| Link::new(id, name)),
         );

tests/rustdoc-json/primitives/no_primitive_impl_pollution.rs

@@ -0,0 +1,2 @@
+//@ !has "$.index[*][?(@.inner=='impl')]"
+fn main() {}