Auto merge of #81557 - GuillaumeGomez:primitive-search, r=ollie27

Fix primitive search in parameters and returned values

Part of #60485.
Fixes #74780.

Replacing #74879.

cc `@camelid` `@jyn514` `@CraftSpider`
r? `@ollie27`

src/librustdoc/clean/types.rs

@@ -1301,6 +1301,7 @@ crate enum TypeKind {
     Attr,
     Derive,
     TraitAlias,
+    Primitive,
 }
 
 crate trait GetDefId {
@@ -1403,6 +1404,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) =
-                                    ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx))
-                                {
-                                    res.insert((ty, kind));
-                                }
+                                insert(&mut res, cx, ty);
                             }
                         }
                     }
@@ -212,26 +217,22 @@ 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)) {
-                            res.insert((ty.clone(), kind));
-                        }
+                        insert(&mut res, cx, ty);
                     }
                 }
             }
         }
     } else {
-        if let Some(kind) = arg.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
-            res.insert((arg.clone(), kind));
-        }
+        insert(&mut res, cx, arg.clone());
         if let Some(gens) = arg.generics() {
             for gen in gens.iter() {
                 if gen.is_full_generic() {
                     let adds = get_real_types(generics, gen, cx, recurse + 1);
                     if !adds.is_empty() {
                         res.extend(adds);
                     }
-                } else if let Some(kind) = gen.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
-                    res.insert((gen.clone(), kind));
+                } else {
+                    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

src/test/rustdoc-js/primitive.js

@@ -0,0 +1,25 @@
+// exact-check
+
+const QUERY = [
+    "i32",
+    "str",
+    "TotoIsSomewhere",
+];
+
+const EXPECTED = [
+    {
+        'in_args': [
+            { 'path': 'primitive', 'name': 'foo' },
+        ],
+    },
+    {
+        'returned': [
+            { 'path': 'primitive', 'name': 'foo' },
+        ],
+    },
+    {
+        'others': [],
+        'in_args': [],
+        'returned': [],
+    },
+];

src/test/rustdoc-js/primitive.rs

@@ -0,0 +1,5 @@
+pub fn foo(i: i32) -> &'static str {
+    "hello"
+}
+
+pub fn foo2<TotoIsSomewhere>(i: &TotoIsSomewhere, j: TotoIsSomewhere) {}

src/tools/rustdoc-js/tester.js

@@ -203,6 +203,10 @@ function betterLookingDiff(entry, data) {
         if (!entry.hasOwnProperty(key)) {
             continue;
         }
+        if (!data || !data.hasOwnProperty(key)) {
+            output += '-' + spaces + contentToDiffLine(key, entry[key]) + '\n';
+            continue;
+        }
         let value = data[key];
         if (value !== entry[key]) {
             output += '-' + spaces + contentToDiffLine(key, entry[key]) + '\n';