Put back primitives in search

src/librustdoc/clean/types.rs

@@ -1302,6 +1302,7 @@ crate enum TypeKind {
     Attr,
     Derive,
     TraitAlias,
+    Primitive,
 }
 
 crate trait GetDefId {
@@ -1404,6 +1405,16 @@ impl Type {
         matches!(self, Type::Generic(_))
     }
 
+    crate fn is_primitive(&self) -> bool {
+        match self {
+            Self::Primitive(_) => true,
+            Self::BorrowedRef { ref type_, .. } | Self::RawPointer(_, ref type_) => {
+                type_.is_primitive()
+            }
+            _ => false,
+        }
+    }
+
     crate fn projection(&self) -> Option<(&Type, DefId, Symbol)> {
         let (self_, trait_, name) = match self {
             QPath { self_type, trait_, name } => (self_type, trait_, name),

src/librustdoc/clean/utils.rs

@@ -171,11 +171,20 @@ crate fn get_real_types(
     cx: &DocContext<'_>,
     recurse: i32,
 ) -> FxHashSet<(Type, TypeKind)> {
+    fn insert(res: &mut FxHashSet<(Type, TypeKind)>, cx: &DocContext<'_>, ty: Type) {
+        if let Some(kind) = ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+            res.insert((ty, kind));
+        } else if ty.is_primitive() {
+            // This is a primitive, let's store it as such.
+            res.insert((ty, TypeKind::Primitive));
+        }
+    }
     let mut res = FxHashSet::default();
     if recurse >= 10 {
         // FIXME: remove this whole recurse thing when the recursion bug is fixed
         return res;
     }
+
     if arg.is_full_generic() {
         let arg_s = Symbol::intern(&arg.print(&cx.cache).to_string());
         if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g {
@@ -194,11 +203,7 @@ crate fn get_real_types(
                             if !adds.is_empty() {
                                 res.extend(adds);
                             } else if !ty.is_full_generic() {
-                                if let Some(kind) =
+                                insert(&mut res, cx, ty);
-                                    ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx))
-                                {
-                                    res.insert((ty, kind));
-                                }
                             }
                         }
                     }
@@ -212,17 +217,13 @@ crate fn get_real_types(
                     if !adds.is_empty() {
                         res.extend(adds);
                     } else if !ty.is_full_generic() {
-                        if let Some(kind) = ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+                        insert(&mut res, cx, ty);
-                            res.insert((ty.clone(), kind));
-                        }
                     }
                 }
             }
         }
     } else {
-        if let Some(kind) = arg.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+        insert(&mut res, cx, arg.clone());
-            res.insert((arg.clone(), kind));
-        }
         if let Some(gens) = arg.generics() {
             for gen in gens.iter() {
                 if gen.is_full_generic() {
@@ -230,8 +231,8 @@ crate fn get_real_types(
                     if !adds.is_empty() {
                         res.extend(adds);
                     }
-                } else if let Some(kind) = gen.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+                } else {
-                    res.insert((gen.clone(), kind));
+                    insert(&mut res, cx, gen.clone());
                 }
             }
         }

src/librustdoc/formats/item_type.rs

@@ -119,6 +119,7 @@ impl From<clean::TypeKind> for ItemType {
             clean::TypeKind::Attr => ItemType::ProcAttribute,
             clean::TypeKind::Derive => ItemType::ProcDerive,
             clean::TypeKind::TraitAlias => ItemType::TraitAlias,
+            clean::TypeKind::Primitive => ItemType::Primitive,
         }
     }
 }

src/librustdoc/html/render/cache.rs

@@ -78,7 +78,7 @@ crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String {
                 desc: item.doc_value().map_or_else(String::new, |s| short_markdown_summary(&s)),
                 parent: Some(did),
                 parent_idx: None,
-                search_type: get_index_search_type(&item, None),
+                search_type: get_index_search_type(&item, Some(cache)),
             });
             for alias in item.attrs.get_doc_aliases() {
                 cache