rustdoc-search: store the real name of type parameters

In order to show the type signature, this has to be stored somewhere.

Author: notriddle

src/librustdoc/html/render/mod.rs

@@ -200,6 +200,7 @@ pub(crate) struct IndexItemFunctionType {
     inputs: Vec<RenderType>,
     output: Vec<RenderType>,
     where_clause: Vec<Vec<RenderType>>,
+    param_names: Vec<Symbol>,
 }
 
 impl IndexItemFunctionType {

src/librustdoc/html/render/search_index.rs

@@ -48,6 +48,7 @@ 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;
@@ -680,6 +681,23 @@ 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.
@@ -701,7 +719,7 @@ pub(crate) fn build_index<'tcx>(
         // We need to escape double quotes for the JSON.
         .replace("\\\"", "\\\\\"")
     );
-    SerializedSearchIndex { index, desc }
+    SerializedSearchIndex { index, desc, param_names }
 }
 
 pub(crate) fn get_function_type_for_search<'tcx>(
@@ -737,7 +755,7 @@ pub(crate) fn get_function_type_for_search<'tcx>(
             None
         }
     });
-    let (mut inputs, mut output, where_clause) = match *item.kind {
+    let (mut inputs, mut output, param_names, where_clause) = match *item.kind {
         clean::FunctionItem(ref f) | clean::MethodItem(ref f, _) | clean::TyMethodItem(ref f) => {
             get_fn_inputs_and_outputs(f, tcx, impl_or_trait_generics, cache)
         }
@@ -747,7 +765,7 @@ pub(crate) fn get_function_type_for_search<'tcx>(
     inputs.retain(|a| a.id.is_some() || a.generics.is_some());
     output.retain(|a| a.id.is_some() || a.generics.is_some());
 
-    Some(IndexItemFunctionType { inputs, output, where_clause })
+    Some(IndexItemFunctionType { inputs, output, where_clause, param_names })
 }
 
 fn get_index_type(
@@ -1262,7 +1280,7 @@ fn get_fn_inputs_and_outputs<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_or_trait_generics: Option<&(clean::Type, clean::Generics)>,
     cache: &Cache,
-) -> (Vec<RenderType>, Vec<RenderType>, Vec<Vec<RenderType>>) {
+) -> (Vec<RenderType>, Vec<RenderType>, Vec<Symbol>, Vec<Vec<RenderType>>) {
     let decl = &func.decl;
 
     let mut rgen: FxHashMap<SimplifiedParam, (isize, Vec<RenderType>)> = Default::default();
@@ -1308,7 +1326,21 @@ fn get_fn_inputs_and_outputs<'tcx>(
     let mut ret_types = Vec::new();
     simplify_fn_type(self_, generics, &decl.output, tcx, 0, &mut ret_types, &mut rgen, true, cache);
 
-    let mut simplified_params = rgen.into_values().collect::<Vec<_>>();
-    simplified_params.sort_by_key(|(idx, _)| -idx);
-    (arg_types, ret_types, simplified_params.into_iter().map(|(_idx, traits)| traits).collect())
+    let mut simplified_params = rgen.into_iter().collect::<Vec<_>>();
+    simplified_params.sort_by_key(|(_, (idx, _))| -idx);
+    (
+        arg_types,
+        ret_types,
+        simplified_params
+            .iter()
+            .map(|(name, (_idx, _traits))| match name {
+                SimplifiedParam::Symbol(name) => *name,
+                SimplifiedParam::Anonymous(_) => kw::Empty,
+                SimplifiedParam::AssociatedType(def_id, name) => {
+                    Symbol::intern(&format!("{}::{}", tcx.item_name(*def_id), name))
+                }
+            })
+            .collect(),
+        simplified_params.into_iter().map(|(_name, (_idx, traits))| traits).collect(),
+    )
 }

src/librustdoc/html/render/write_shared.rs

@@ -361,6 +361,23 @@ 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}, JSON.parse('{data}'))"##,
+                kratename = serde_json::to_string(&kratename).unwrap(),
+                data = search_index.param_names,
+            )
+            .into_bytes()
+        ),
+        &path
+    );
 
     write_invocation_specific("crates.js", &|| {
         let krates = krates.iter().map(|k| format!("\"{k}\"")).join(",");