Mark stripped items

removing them creates dangling references

Author: P1n3appl3

src/librustdoc/json/conversions.rs

@@ -29,7 +29,10 @@ impl From<clean::Item> for Item {
             id: def_id.into(),
             crate_id: def_id.krate.as_u32(),
             name,
-            stripped: inner == clean::StrippedItem(_),
+            stripped: match inner {
+                clean::StrippedItem(_) => true,
+                _ => false,
+            },
             source: source.into(),
             visibility: visibility.into(),
             docs: attrs.collapsed_doc_value().unwrap_or_default(),
@@ -179,27 +182,18 @@ impl From<clean::ItemEnum> for ItemEnum {
                 bounds: g.into_iter().map(Into::into).collect(),
                 default: t.map(Into::into),
             },
-            StrippedItem(inner) => ItemEnum::StrippedItem(Box::new((*inner).into())),
+            StrippedItem(inner) => (*inner).into(),
             _ => panic!("{:?} is not supported for JSON output", item),
         }
     }
 }
 
-fn remove_stripped(items: &[clean::Item]) -> Vec<Id> {
-    items
-        .into_iter()
-        .filter_map(|i| {
-            if let clean::StrippedItem(_) = i.inner {
-                return None;
-            }
-            Some(i.def_id.into())
-        })
-        .collect()
-}
-
 impl From<clean::Module> for Module {
     fn from(module: clean::Module) -> Self {
-        Module { is_crate: module.is_crate, items: remove_stripped(&module.items) }
+        Module {
+            is_crate: module.is_crate,
+            items: module.items.into_iter().map(|i| i.def_id.into()).collect(),
+        }
     }
 }
 
@@ -210,7 +204,7 @@ impl From<clean::Struct> for Struct {
             struct_type: struct_type.into(),
             generics: generics.into(),
             fields_stripped,
-            fields: remove_stripped(&fields),
+            fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -223,7 +217,7 @@ impl From<clean::Union> for Struct {
             struct_type: struct_type.into(),
             generics: generics.into(),
             fields_stripped,
-            fields: remove_stripped(&fields),
+            fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -410,7 +404,7 @@ impl From<clean::Trait> for Trait {
         Trait {
             is_auto: auto,
             is_unsafe: unsafety == rustc_hir::Unsafety::Unsafe,
-            items: remove_stripped(&items),
+            items: items.into_iter().map(|i| i.def_id.into()).collect(),
             generics: generics.into(),
             bounds: bounds.into_iter().map(Into::into).collect(),
             implementors: Vec::new(), // Added in JsonRenderer::item
@@ -437,7 +431,7 @@ impl From<clean::Impl> for Impl {
             provided_trait_methods: provided_trait_methods.into_iter().collect(),
             trait_: trait_.map(Into::into),
             for_: for_.into(),
-            items: remove_stripped(&items),
+            items: items.into_iter().map(|i| i.def_id.into()).collect(),
             negative: polarity == Some(clean::ImplPolarity::Negative),
             synthetic,
             blanket_impl: blanket_impl.map(Into::into),
@@ -476,7 +470,7 @@ impl From<clean::Enum> for Enum {
         Enum {
             generics: generics.into(),
             variants_stripped,
-            variants: remove_stripped(&variants.into_iter().collect::<Vec<_>>()),
+            variants: variants.into_iter().map(|i| i.def_id.into()).collect(),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -489,7 +483,7 @@ impl From<clean::VariantStruct> for Struct {
             struct_type: struct_type.into(),
             generics: Default::default(),
             fields_stripped,
-            fields: remove_stripped(&fields),
+            fields: fields.into_iter().map(|i| i.def_id.into()).collect(),
             impls: Vec::new(),
         }
     }
@@ -501,7 +495,7 @@ impl From<clean::Variant> for Variant {
         match variant.kind {
             CLike => Variant::Plain,
             Tuple(t) => Variant::Tuple(t.into_iter().map(Into::into).collect()),
-            Struct(s) => Variant::Struct(remove_stripped(&s.fields)),
+            Struct(s) => Variant::Struct(s.fields.into_iter().map(|i| i.def_id.into()).collect()),
         }
     }
 }

src/librustdoc/json/mod.rs

@@ -99,6 +99,7 @@ impl JsonRenderer {
                                 .0
                                 .last()
                                 .map(Clone::clone),
+                            stripped: false,
                             visibility: types::Visibility::Public,
                             kind: types::ItemKind::Trait,
                             inner: types::ItemEnum::TraitItem(trait_item.clone().into()),
@@ -139,17 +140,8 @@ impl FormatRenderer for JsonRenderer {
     /// the hashmap because certain items (traits and types) need to have their mappings for trait
     /// implementations filled out before they're inserted.
     fn item(&mut self, item: clean::Item, cache: &Cache) -> Result<(), Error> {
-        if let clean::StrippedItem(_) = item.inner {
-            return Ok(());
-        }
-
         // Flatten items that recursively store other items
-        item.inner.inner_items().for_each(|i| {
-            if let clean::StrippedItem(_) = i.inner {
-            } else {
-                self.item(i.clone(), cache).unwrap()
-            }
-        });
+        item.inner.inner_items().for_each(|i| self.item(i.clone(), cache).unwrap());
 
         let id = item.def_id;
         let mut new_item: types::Item = item.into();