Separate out some fields into "sub-struct" (name pending bikeshed)

Author: yotamofek

src/librustdoc/formats/cache.rs

@@ -15,7 +15,7 @@ use crate::core::DocContext;
 use crate::fold::DocFolder;
 use crate::formats::Impl;
 use crate::formats::item_type::ItemType;
-use crate::html::render::IndexItem;
+use crate::html::render::{IndexItem, IndexItemSubStruct};
 use crate::visit_lib::RustdocEffectiveVisibilities;
 
 /// This cache is used to store information about the [`clean::Crate`] being
@@ -582,18 +582,26 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
         _ => item_def_id,
     };
     let (impl_id, trait_parent) = cache.parent_stack_last_impl_and_trait_id();
-    let index_item = IndexItem::new(
+    let sub_struct = IndexItemSubStruct::new(
         tcx,
         cache,
         item,
-        Some(name),
-        Some(defid),
-        parent_path.to_vec(),
         parent_did,
-        impl_id,
-        trait_parent,
         clean_impl_generics(cache.parent_stack.last()).as_ref(),
     );
+    let index_item = IndexItem {
+        ty: item.type_(),
+        defid: Some(defid),
+        name,
+        module_path: parent_path.to_vec(),
+        parent: parent_did,
+        parent_idx: None,
+        trait_parent,
+        trait_parent_idx: None,
+        exact_module_path: None,
+        impl_id,
+        sub_struct,
+    };
 
     cache.search_index.push(index_item);
 }

src/librustdoc/html/render/mod.rs

@@ -81,7 +81,6 @@ use crate::html::format::{
 use crate::html::markdown::{
     HeadingOffset, IdMap, Markdown, MarkdownItemInfo, MarkdownSummaryLine, short_markdown_summary,
 };
-use crate::html::render::search_index::get_function_type_for_search;
 use crate::html::static_files::SCRAPE_EXAMPLES_HELP_MD;
 use crate::html::{highlight, sources};
 use crate::scrape_examples::{CallData, CallLocation};
@@ -125,63 +124,48 @@ enum RenderMode {
 // Helper structs for rendering items/sidebars and carrying along contextual
 // information
 
-/// Struct representing one entry in the JS search index. These are all emitted
-/// by hand to a large JS file at the end of cache-creation.
 #[derive(Debug)]
-pub(crate) struct IndexItem {
-    pub(crate) ty: ItemType,
-    pub(crate) defid: Option<DefId>,
-    pub(crate) name: Symbol,
-    pub(crate) module_path: Vec<Symbol>,
+pub(crate) struct IndexItemSubStruct {
     pub(crate) desc: String,
-    pub(crate) parent: Option<DefId>,
-    pub(crate) parent_idx: Option<usize>,
-    pub(crate) trait_parent: Option<DefId>,
-    pub(crate) trait_parent_idx: Option<usize>,
-    pub(crate) exact_module_path: Option<Vec<Symbol>>,
-    pub(crate) impl_id: Option<DefId>,
     pub(crate) search_type: Option<IndexItemFunctionType>,
     pub(crate) aliases: Box<[Symbol]>,
     pub(crate) deprecation: Option<Deprecation>,
 }
 
-impl IndexItem {
+impl IndexItemSubStruct {
     pub(crate) fn new(
         tcx: TyCtxt<'_>,
         cache: &Cache,
         item: &Item,
-        name: Option<Symbol>,
-        defid: Option<DefId>,
-        module_path: Vec<Symbol>,
         parent_did: Option<DefId>,
-        impl_id: Option<DefId>,
-        trait_parent: Option<DefId>,
         impl_generics: Option<&(clean::Type, clean::Generics)>,
     ) -> Self {
         let desc = short_markdown_summary(&item.doc_value(), &item.link_names(cache));
-        let search_type = get_function_type_for_search(item, tcx, impl_generics, parent_did, cache);
+        let search_type =
+            search_index::get_function_type_for_search(item, tcx, impl_generics, parent_did, cache);
         let aliases = item.attrs.get_doc_aliases();
         let deprecation = item.deprecation(tcx);
-
-        Self {
-            ty: item.type_(),
-            defid: defid.or_else(|| item.item_id.as_def_id()),
-            name: name.or(item.name).unwrap(),
-            module_path,
-            desc,
-            parent: parent_did,
-            parent_idx: None,
-            trait_parent,
-            trait_parent_idx: None,
-            exact_module_path: None,
-            impl_id,
-            search_type,
-            aliases,
-            deprecation,
-        }
+        Self { desc, search_type, aliases, deprecation }
     }
 }
 
+/// Struct representing one entry in the JS search index. These are all emitted
+/// by hand to a large JS file at the end of cache-creation.
+#[derive(Debug)]
+pub(crate) struct IndexItem {
+    pub(crate) ty: ItemType,
+    pub(crate) defid: Option<DefId>,
+    pub(crate) name: Symbol,
+    pub(crate) module_path: Vec<Symbol>,
+    pub(crate) parent: Option<DefId>,
+    pub(crate) parent_idx: Option<usize>,
+    pub(crate) trait_parent: Option<DefId>,
+    pub(crate) trait_parent_idx: Option<usize>,
+    pub(crate) exact_module_path: Option<Vec<Symbol>>,
+    pub(crate) impl_id: Option<DefId>,
+    pub(crate) sub_struct: IndexItemSubStruct,
+}
+
 /// A type used for the search index.
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct RenderType {

src/librustdoc/html/render/search_index.rs

@@ -29,7 +29,9 @@ use crate::error::Error;
 use crate::formats::cache::{Cache, OrphanImplItem};
 use crate::formats::item_type::ItemType;
 use crate::html::markdown::short_markdown_summary;
-use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
+use crate::html::render::{
+    self, IndexItem, IndexItemFunctionType, IndexItemSubStruct, RenderType, RenderTypeId,
+};
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub(crate) struct SerializedSearchIndex {
@@ -1261,18 +1263,21 @@ pub(crate) fn build_index(
         &cache.orphan_impl_items
     {
         if let Some((fqp, _)) = cache.paths.get(&parent) {
-            search_index.push(IndexItem::new(
-                tcx,
-                cache,
-                item,
-                None,
-                None,
-                fqp[..fqp.len() - 1].to_vec(),
-                Some(parent),
-                impl_id,
+            let sub_struct =
+                IndexItemSubStruct::new(tcx, cache, item, Some(parent), impl_generics.as_ref());
+            search_index.push(IndexItem {
+                ty: item.type_(),
+                defid: item.item_id.as_def_id(),
+                name: item.name.unwrap(),
+                module_path: fqp[..fqp.len() - 1].to_vec(),
+                parent: Some(parent),
+                parent_idx: None,
                 trait_parent,
-                impl_generics.as_ref(),
-            ));
+                trait_parent_idx: None,
+                exact_module_path: None,
+                impl_id,
+                sub_struct,
+            });
         }
     }
 
@@ -1508,7 +1513,7 @@ pub(crate) fn build_index(
                 trait_parent: item.trait_parent_idx,
                 module_path,
                 exact_module_path,
-                deprecated: item.deprecation.is_some(),
+                deprecated: item.sub_struct.deprecation.is_some(),
                 associated_item_disambiguator: if let Some(impl_id) = item.impl_id
                     && let Some(parent_idx) = item.parent_idx
                     && associated_item_duplicates
@@ -1523,12 +1528,12 @@ pub(crate) fn build_index(
                 },
                 krate: crate_idx,
             },
-            item.desc.to_string(),
+            item.sub_struct.desc.to_string(),
         );
 
         // Aliases
         // -------
-        for alias in &item.aliases[..] {
+        for alias in &item.sub_struct.aliases {
             serialized_index.push_alias(alias.as_str().to_string(), new_entry_id);
         }
 
@@ -1801,7 +1806,7 @@ pub(crate) fn build_index(
                 _ => {}
             }
         }
-        if let Some(search_type) = &mut item.search_type {
+        if let Some(search_type) = &mut item.sub_struct.search_type {
             let mut used_in_function_inputs = BTreeSet::new();
             let mut used_in_function_output = BTreeSet::new();
             for item in &mut search_type.inputs {