rustdoc-search: merge type params into search-index

This commit tweaks the format to reduce its size and
merges it into the index, which should reduce the amount of
network traffic overall.

Author: notriddle

src/librustdoc/html/render/search_index.rs

@@ -48,7 +48,6 @@ use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, Re
 pub(crate) struct SerializedSearchIndex {
     pub(crate) index: String,
     pub(crate) desc: Vec<(usize, String)>,
-    pub(crate) param_names: String,
 }
 
 const DESC_INDEX_SHARD_LEN: usize = 128 * 1024;
@@ -621,9 +620,25 @@ pub(crate) fn build_index<'tcx>(
                 full_paths.push((*index, path));
             }
 
+            let param_names: Vec<(usize, String)> = {
+                let mut prev = Vec::new();
+                let mut result = Vec::new();
+                for (index, item) in self.items.iter().enumerate() {
+                    if let Some(ty) = &item.search_type
+                        && let my =
+                            ty.param_names.iter().map(|sym| sym.as_str()).collect::<Vec<_>>()
+                        && my != prev
+                    {
+                        result.push((index, my.join(",")));
+                        prev = my;
+                    }
+                }
+                result
+            };
+
             let has_aliases = !self.aliases.is_empty();
             let mut crate_data =
-                serializer.serialize_struct("CrateData", if has_aliases { 9 } else { 8 })?;
+                serializer.serialize_struct("CrateData", if has_aliases { 13 } else { 12 })?;
             crate_data.serialize_field("t", &types)?;
             crate_data.serialize_field("n", &names)?;
             crate_data.serialize_field("q", &full_paths)?;
@@ -635,6 +650,7 @@ pub(crate) fn build_index<'tcx>(
             crate_data.serialize_field("b", &self.associated_item_disambiguators)?;
             crate_data.serialize_field("c", &bitmap_to_string(&deprecated))?;
             crate_data.serialize_field("e", &bitmap_to_string(&self.empty_desc))?;
+            crate_data.serialize_field("P", &param_names)?;
             if has_aliases {
                 crate_data.serialize_field("a", &self.aliases)?;
             }
@@ -681,23 +697,6 @@ pub(crate) fn build_index<'tcx>(
         desc.iter().map(|(len, _)| *len).sum::<usize>() + empty_desc.len()
     );
 
-    let param_names = {
-        let result: Vec<Vec<&str>> = crate_items
-            .iter()
-            .map(|item| match &item.search_type {
-                Some(ty) => ty.param_names.iter().map(|sym| sym.as_str()).collect(),
-                None => Vec::new(),
-            })
-            .collect();
-        serde_json::to_string(&result)
-            .expect("failed serde conversion")
-            // All these `replace` calls are because we have to go through JS string for JSON content.
-            .replace('\\', r"\\")
-            .replace('\'', r"\'")
-            // We need to escape double quotes for the JSON.
-            .replace("\\\"", "\\\\\"")
-    };
-
     // The index, which is actually used to search, is JSON
     // It uses `JSON.parse(..)` to actually load, since JSON
     // parses faster than the full JavaScript syntax.
@@ -719,7 +718,7 @@ pub(crate) fn build_index<'tcx>(
         // We need to escape double quotes for the JSON.
         .replace("\\\"", "\\\\\"")
     );
-    SerializedSearchIndex { index, desc, param_names }
+    SerializedSearchIndex { index, desc }
 }
 
 pub(crate) fn get_function_type_for_search<'tcx>(

src/librustdoc/html/render/write_shared.rs

@@ -361,22 +361,6 @@ else if (window.initSearch) window.initSearch(searchIndex);
             &path
         );
     }
-    let output_filename = static_files::suffix_path(
-        &format!("{kratename}-param-names.js"),
-        &cx.shared.resource_suffix,
-    );
-    let path = search_desc_dir.join(output_filename);
-    try_err!(
-        std::fs::write(
-            &path,
-            &format!(
-                r##"searchState.loadedParamNames('{kratename}','{data}')"##,
-                data = search_index.param_names,
-            )
-            .into_bytes()
-        ),
-        &path
-    );
 
     write_invocation_specific("crates.js", &|| {
         let krates = krates.iter().map(|k| format!("\"{k}\"")).join(",");

src/librustdoc/html/static/js/main.js

@@ -353,26 +353,6 @@ function preLoadCss(cssUrl) {
         loadedDescShard: function(crate, shard, data) {
             this.descShards.get(crate)[shard].resolve(data.split("\n"));
         },
-        paramNameShards: new Map(),
-        paramNameResolvers: new Map(),
-        loadParamNames: async function(crate) {
-            if (this.paramNameShards.has(crate)) {
-                return this.paramNameShards.get(crate);
-            }
-            const promise = new Promise((resolve, reject) => {
-                this.paramNameResolvers.set(crate, resolve);
-                const url = resourcePath(
-                    `search.desc/${crate}/${crate}-param-names`,
-                    ".js",
-                );
-                loadScript(url, reject);
-            });
-            this.paramNameShards.set(crate, promise);
-            return promise;
-        },
-        loadedParamNames: function(crate, data) {
-            this.paramNameResolvers.get(crate)(JSON.parse(data));
-        },
     };
 
     const toggleAllDocsId = "toggle-all-docs";

src/librustdoc/html/static/js/search.js

@@ -1501,7 +1501,7 @@ function initSearch(rawSearchIndex) {
             const mappedNames = new Map();
             const whereClause = new Map();
 
-            const fnParamNames = (await searchState.loadParamNames(obj.crate))[obj.bitIndex - 1];
+            const fnParamNames = obj.paramNames;
             const queryParamNames = [];
             /**
              * Recursively writes a map of IDs to query generic names,
@@ -2525,6 +2525,7 @@ function initSearch(rawSearchIndex) {
                 ty: item.ty,
                 parent: item.parent,
                 type: item.type,
+                paramNames: item.paramNames,
                 is_alias: true,
                 bitIndex: item.bitIndex,
                 implDisambiguator: item.implDisambiguator,
@@ -4011,6 +4012,13 @@ ${item.displayPath}<span class="${type}">${name}</span>\
             searchIndexEmptyDesc.set(crate, new RoaringBitmap(crateCorpus.e));
             let descIndex = 0;
 
+            /**
+             * List of generic function type parameter names.
+             * Used for display, not for searching.
+             * @type {[string]}
+             */
+            let lastParamNames = [];
+
             // This object should have exactly the same set of fields as the "row"
             // object defined below. Your JavaScript runtime will thank you.
             // https://mathiasbynens.be/notes/shapes-ics
@@ -4025,6 +4033,7 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                 desc: crateCorpus.doc,
                 parent: undefined,
                 type: null,
+                paramNames: lastParamNames,
                 id,
                 word: crate,
                 normalizedName: crate.indexOf("_") === -1 ? crate : crate.replace(/_/g, ""),
@@ -4061,6 +4070,10 @@ ${item.displayPath}<span class="${type}">${name}</span>\
             // an array of [(String) alias name
             //             [Number] index to items]
             const aliases = crateCorpus.a;
+            // an array of [(Number) item index,
+            //              (String) comma-separated list of function generic param names]
+            // an item whose index is not present will fall back to the previous present path
+            const itemParamNames = new Map(crateCorpus.P);
 
             // an array of [{name: String, ty: Number}]
             const lowercasePaths = [];
@@ -4119,6 +4132,9 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                     word = itemNames[i].toLowerCase();
                 }
                 const path = itemPaths.has(i) ? itemPaths.get(i) : lastPath;
+                const paramNames = itemParamNames.has(i) ?
+                    itemParamNames.get(i).split(",") :
+                    lastParamNames;
                 const type = itemFunctionDecoder.next();
                 if (type !== null) {
                     if (type) {
@@ -4149,6 +4165,7 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                     exactPath: itemReexports.has(i) ? itemPaths.get(itemReexports.get(i)) : path,
                     parent: itemParentIdxs[i] > 0 ? paths[itemParentIdxs[i] - 1] : undefined,
                     type,
+                    paramNames,
                     id,
                     word,
                     normalizedName: word.indexOf("_") === -1 ? word : word.replace(/_/g, ""),
@@ -4158,6 +4175,7 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                 id += 1;
                 searchIndex.push(row);
                 lastPath = row.path;
+                lastParamNames = row.paramNames;
                 if (!searchIndexEmptyDesc.get(crate).contains(bitIndex)) {
                     descIndex += 1;
                 }

src/tools/rustdoc-js/tester.js

@@ -428,33 +428,6 @@ function loadSearchJS(doc_folder, resource_suffix) {
             //console.log(this.descShards);
             this.descShards.get(crate)[shard].resolve(data.split("\n"));
         },
-        paramNameShards: new Map(),
-        paramNameResolvers: new Map(),
-        loadParamNames: async function(crate) {
-            if (this.paramNameShards.has(crate)) {
-                return this.paramNameShards.get(crate);
-            } else {
-                const promise = new Promise((resolve, reject) => {
-                    this.paramNameResolvers.set(crate, resolve);
-                    const fname = `${crate}-param-names${resource_suffix}.js`;
-                    fs.readFile(
-                        `${doc_folder}/search.desc/${crate}/${fname}`,
-                        (err, data) => {
-                            if (err) {
-                                reject(err);
-                            } else {
-                                eval(data.toString("utf8"));
-                            }
-                        },
-                    );
-                });
-                this.paramNameShards.set(crate, promise);
-                return promise;
-            }
-        },
-        loadedParamNames: function(crate, data) {
-            this.paramNameResolvers.get(crate)(JSON.parse(data));
-        },
     };
 
     const staticFiles = path.join(doc_folder, "static.files");